@aws-amplify/core 5.8.6-api-v6-models.b3abc9b.0 → 6.0.0

package/lib/providers/pinpoint/apis/updateEndpoint.js

@@ -0,0 +1,75 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateEndpoint = void 0;
+const amplifyUuid_1 = require("../../../utils/amplifyUuid");
+const getClientInfo_1 = require("../../../utils/getClientInfo");
+const pinpoint_1 = require("../../../awsClients/pinpoint");
+const utils_1 = require("../utils");
+/**
+ * @internal
+ */
+const updateEndpoint = async ({ address, appId, category, channelType, credentials, identityId, optOut, region, userAttributes, userId, userProfile, userAgentValue, }) => {
+    const endpointId = await (0, utils_1.getEndpointId)(appId, category);
+    // only generate a new endpoint id if one was not found in cache
+    const createdEndpointId = !endpointId ? (0, amplifyUuid_1.amplifyUuid)() : undefined;
+    const { customProperties, demographic, email, location, metrics, name, plan, } = userProfile ?? {};
+    const clientInfo = (0, getClientInfo_1.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 = {
+        ApplicationId: appId,
+        EndpointId: endpointId ?? createdEndpointId,
+        EndpointRequest: {
+            RequestId: (0, amplifyUuid_1.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 (0, pinpoint_1.updateEndpoint)({ credentials, region, userAgentValue }, input);
+    // if we had to create an endpoint id, we need to now cache it
+    if (!!createdEndpointId) {
+        return (0, utils_1.cacheEndpointId)(appId, category, createdEndpointId);
+    }
+};
+exports.updateEndpoint = updateEndpoint;

package/lib/providers/pinpoint/index.d.ts

@@ -0,0 +1,3 @@
+export * from './apis';
+export { PinpointAnalyticsEvent, PinpointServiceOptions, UpdateEndpointException, } from './types';
+export { resolveEndpointId } from './utils';

package/lib/providers/pinpoint/index.js

@@ -0,0 +1,24 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEndpointId = exports.UpdateEndpointException = void 0;
+__exportStar(require("./apis"), exports);
+var types_1 = require("./types");
+Object.defineProperty(exports, "UpdateEndpointException", { enumerable: true, get: function () { return types_1.UpdateEndpointException; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "resolveEndpointId", { enumerable: true, get: function () { return utils_1.resolveEndpointId; } });

package/lib/providers/pinpoint/types/buffer.d.ts

@@ -0,0 +1,25 @@
+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/lib/providers/pinpoint/types/buffer.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/providers/pinpoint/types/errors.d.ts

@@ -0,0 +1,9 @@
+export declare enum UpdateEndpointException {
+    BadRequestException = "BadRequestException",
+    ForbiddenException = "ForbiddenException",
+    InternalServerErrorException = "InternalServerErrorException",
+    MethodNotAllowedException = "MethodNotAllowedException",
+    NotFoundException = "NotFoundException",
+    PayloadTooLargeException = "PayloadTooLargeException",
+    TooManyRequestsException = "TooManyRequestsException"
+}

package/lib/providers/pinpoint/types/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateEndpointException = void 0;
+var UpdateEndpointException;
+(function (UpdateEndpointException) {
+    UpdateEndpointException["BadRequestException"] = "BadRequestException";
+    UpdateEndpointException["ForbiddenException"] = "ForbiddenException";
+    UpdateEndpointException["InternalServerErrorException"] = "InternalServerErrorException";
+    UpdateEndpointException["MethodNotAllowedException"] = "MethodNotAllowedException";
+    UpdateEndpointException["NotFoundException"] = "NotFoundException";
+    UpdateEndpointException["PayloadTooLargeException"] = "PayloadTooLargeException";
+    UpdateEndpointException["TooManyRequestsException"] = "TooManyRequestsException";
+})(UpdateEndpointException = exports.UpdateEndpointException || (exports.UpdateEndpointException = {}));

package/lib/providers/pinpoint/types/index.d.ts

@@ -0,0 +1,2 @@
+export { UpdateEndpointException } from './errors';
+export * from './pinpoint';

package/lib/providers/pinpoint/types/index.js

@@ -0,0 +1,22 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateEndpointException = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "UpdateEndpointException", { enumerable: true, get: function () { return errors_1.UpdateEndpointException; } });
+__exportStar(require("./pinpoint"), exports);

package/lib/providers/pinpoint/types/pinpoint.d.ts

@@ -0,0 +1,43 @@
+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>;
+};
+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;
+};
+export {};

package/lib/providers/pinpoint/types/pinpoint.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/providers/pinpoint/utils/PinpointEventBuffer.d.ts

@@ -0,0 +1,24 @@
+import { EventBufferConfig, BufferedEvent } from '../types/buffer';
+import { AuthSession } from '../../../singleton/Auth/types';
+export declare class PinpointEventBuffer {
+    private _config;
+    private _interval;
+    private _buffer;
+    private _pause;
+    private _flush;
+    constructor(config: EventBufferConfig);
+    push(event: BufferedEvent): void;
+    pause(): void;
+    resume(): void;
+    flush(): void;
+    identityHasChanged(identityId: AuthSession['identityId']): boolean;
+    flushAll(): void;
+    private _startLoop;
+    private _sendBatch;
+    private _putEvents;
+    private _generateBatchEventParams;
+    private _handlePutEventsFailure;
+    private _processPutEventsSuccessResponse;
+    private _retry;
+    private _bufferToMap;
+}

package/lib/providers/pinpoint/utils/PinpointEventBuffer.js

@@ -0,0 +1,192 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinpointEventBuffer = void 0;
+const Logger_1 = require("../../../Logger");
+const pinpoint_1 = require("../../../awsClients/pinpoint");
+const isAppInForeground_1 = require("./isAppInForeground");
+const logger = new Logger_1.ConsoleLogger('PinpointEventBuffer');
+const RETRYABLE_CODES = [429, 500];
+const ACCEPTED_CODES = [202];
+class PinpointEventBuffer {
+    constructor(config) {
+        this._interval = undefined;
+        this._pause = false;
+        this._flush = false;
+        this._buffer = [];
+        this._config = config;
+        this._sendBatch = this._sendBatch.bind(this);
+        this._startLoop();
+    }
+    push(event) {
+        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 });
+    }
+    pause() {
+        this._pause = true;
+    }
+    resume() {
+        this._pause = false;
+    }
+    flush() {
+        this._flush = true;
+    }
+    identityHasChanged(identityId) {
+        return this._config.identityId !== identityId;
+    }
+    flushAll() {
+        this._putEvents(this._buffer.splice(0, this._buffer.length));
+    }
+    _startLoop() {
+        if (this._interval) {
+            clearInterval(this._interval);
+        }
+        const { flushInterval } = this._config;
+        this._interval = setInterval(this._sendBatch, flushInterval);
+    }
+    _sendBatch() {
+        const bufferLength = this._buffer.length;
+        if (this._flush && !bufferLength && this._interval) {
+            clearInterval(this._interval);
+        }
+        if (this._pause || !bufferLength || !(0, isAppInForeground_1.isAppInForeground)()) {
+            return;
+        }
+        const { flushSize } = this._config;
+        const batchSize = Math.min(flushSize, bufferLength);
+        const bufferSubset = this._buffer.splice(0, batchSize);
+        this._putEvents(bufferSubset);
+    }
+    async _putEvents(buffer) {
+        const eventMap = this._bufferToMap(buffer);
+        const batchEventParams = this._generateBatchEventParams(eventMap);
+        try {
+            const { credentials, region, userAgentValue } = this._config;
+            const data = await (0, pinpoint_1.putEvents)({
+                credentials,
+                region,
+                userAgentValue,
+            }, batchEventParams);
+            this._processPutEventsSuccessResponse(data, eventMap);
+        }
+        catch (err) {
+            return this._handlePutEventsFailure(err, eventMap);
+        }
+    }
+    _generateBatchEventParams(eventMap) {
+        const batchItem = {};
+        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,
+            },
+        };
+    }
+    _handlePutEventsFailure(err, eventMap) {
+        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;
+        }
+    }
+    _processPutEventsSuccessResponse(data, eventMap) {
+        const { Results = {} } = data.EventsResponse ?? {};
+        const retryableEvents = [];
+        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);
+        }
+    }
+    _retry(retryableEvents) {
+        // retryable events that haven't reached the resendLimit
+        const eligibleEvents = [];
+        retryableEvents.forEach((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);
+    }
+    _bufferToMap(buffer) {
+        return buffer.reduce((acc, curVal) => {
+            const [[key, value]] = Object.entries(curVal);
+            acc[key] = value;
+            return acc;
+        }, {});
+    }
+}
+exports.PinpointEventBuffer = PinpointEventBuffer;

package/lib/providers/pinpoint/utils/cacheEndpointId.d.ts

@@ -0,0 +1,7 @@
+import { SupportedCategory } from '../types';
+/**
+ * Writes an endpoint id to a long-lived cache.
+ *
+ * @internal
+ */
+export declare const cacheEndpointId: (appId: string, category: SupportedCategory, endpointId: string) => Promise<void>;

package/lib/providers/pinpoint/utils/cacheEndpointId.js

@@ -0,0 +1,24 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheEndpointId = void 0;
+const __1 = require("../../..");
+const getCacheKey_1 = require("./getCacheKey");
+/**
+ * Writes an endpoint id to a long-lived cache.
+ *
+ * @internal
+ */
+const cacheEndpointId = async (appId, category, endpointId) => {
+    const cacheKey = (0, getCacheKey_1.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 __1.Cache.setItem(cacheKey, endpointId, {
+        expires: expiration,
+        priority: 1,
+    });
+};
+exports.cacheEndpointId = cacheEndpointId;

package/lib/providers/pinpoint/utils/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const BUFFER_SIZE = 1000;
+export declare const FLUSH_SIZE = 100;
+export declare const FLUSH_INTERVAL: number;
+export declare const RESEND_LIMIT = 5;

package/lib/providers/pinpoint/utils/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESEND_LIMIT = exports.FLUSH_INTERVAL = exports.FLUSH_SIZE = exports.BUFFER_SIZE = void 0;
+// Default buffer constants
+exports.BUFFER_SIZE = 1000;
+exports.FLUSH_SIZE = 100;
+exports.FLUSH_INTERVAL = 5 * 1000; // 5s
+exports.RESEND_LIMIT = 5;

package/lib/providers/pinpoint/utils/getCacheKey.d.ts

@@ -0,0 +1,7 @@
+import { SupportedCategory } from '../types';
+/**
+ * Returns a unique cache key for a particular category/appId combination.
+ *
+ * @internal
+ */
+export declare const getCacheKey: (appId: string, category: SupportedCategory) => string;

package/lib/providers/pinpoint/utils/getCacheKey.js

@@ -0,0 +1,13 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCacheKey = void 0;
+const PROVIDER_NAME = 'pinpoint';
+/**
+ * Returns a unique cache key for a particular category/appId combination.
+ *
+ * @internal
+ */
+const getCacheKey = (appId, category) => `${category}:${PROVIDER_NAME}:${appId}`;
+exports.getCacheKey = getCacheKey;

package/lib/providers/pinpoint/utils/getEndpointId.d.ts

@@ -0,0 +1,7 @@
+import { SupportedCategory } from '../types';
+/**
+ * Returns an endpoint id from cache or `undefined` if not found.
+ *
+ * @internal
+ */
+export declare const getEndpointId: (appId: string, category: SupportedCategory) => Promise<string | undefined>;

package/lib/providers/pinpoint/utils/getEndpointId.js

@@ -0,0 +1,18 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpointId = void 0;
+const __1 = require("../../..");
+const getCacheKey_1 = require("./getCacheKey");
+/**
+ * Returns an endpoint id from cache or `undefined` if not found.
+ *
+ * @internal
+ */
+const getEndpointId = async (appId, category) => {
+    const cacheKey = (0, getCacheKey_1.getCacheKey)(appId, category);
+    const cachedEndpointId = await __1.Cache.getItem(cacheKey);
+    return cachedEndpointId ?? undefined;
+};
+exports.getEndpointId = getEndpointId;

package/lib/providers/pinpoint/utils/getEventBuffer.d.ts

@@ -0,0 +1,8 @@
+import { EventBufferConfig } from '../types/buffer';
+import { PinpointEventBuffer } from './PinpointEventBuffer';
+/**
+ * Returns a PinpointEventBuffer instance for the specified region & app ID, creating one if it does not yet exist.
+ *
+ * @internal
+ */
+export declare const getEventBuffer: ({ appId, bufferSize, credentials, flushInterval, flushSize, identityId, region, resendLimit, userAgentValue }: EventBufferConfig) => PinpointEventBuffer;

package/lib/providers/pinpoint/utils/getEventBuffer.js

@@ -0,0 +1,46 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventBuffer = void 0;
+const PinpointEventBuffer_1 = require("./PinpointEventBuffer");
+const constants_1 = require("./constants");
+// Map of buffers by region -> appId
+const eventBufferMap = {};
+/**
+ * Returns a PinpointEventBuffer instance for the specified region & app ID, creating one if it does not yet exist.
+ *
+ * @internal
+ */
+const getEventBuffer = ({ appId, bufferSize = constants_1.BUFFER_SIZE, credentials, flushInterval = constants_1.FLUSH_INTERVAL, flushSize = constants_1.FLUSH_SIZE, identityId, region, resendLimit = constants_1.RESEND_LIMIT, userAgentValue }) => {
+    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_1.PinpointEventBuffer({
+        appId,
+        bufferSize,
+        credentials,
+        flushInterval,
+        flushSize,
+        identityId,
+        region,
+        resendLimit,
+        userAgentValue
+    });
+    if (!eventBufferMap[region]) {
+        eventBufferMap[region] = {};
+    }
+    eventBufferMap[region][appId] = buffer;
+    return buffer;
+};
+exports.getEventBuffer = getEventBuffer;

package/lib/providers/pinpoint/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { cacheEndpointId } from './cacheEndpointId';
+export { getCacheKey } from './getCacheKey';
+export { getEndpointId } from './getEndpointId';
+export { resolveEndpointId } from './resolveEndpointId';

package/lib/providers/pinpoint/utils/index.js

@@ -0,0 +1,13 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEndpointId = exports.getEndpointId = exports.getCacheKey = exports.cacheEndpointId = void 0;
+var cacheEndpointId_1 = require("./cacheEndpointId");
+Object.defineProperty(exports, "cacheEndpointId", { enumerable: true, get: function () { return cacheEndpointId_1.cacheEndpointId; } });
+var getCacheKey_1 = require("./getCacheKey");
+Object.defineProperty(exports, "getCacheKey", { enumerable: true, get: function () { return getCacheKey_1.getCacheKey; } });
+var getEndpointId_1 = require("./getEndpointId");
+Object.defineProperty(exports, "getEndpointId", { enumerable: true, get: function () { return getEndpointId_1.getEndpointId; } });
+var resolveEndpointId_1 = require("./resolveEndpointId");
+Object.defineProperty(exports, "resolveEndpointId", { enumerable: true, get: function () { return resolveEndpointId_1.resolveEndpointId; } });

package/lib/providers/pinpoint/utils/isAppInForeground.d.ts

@@ -0,0 +1 @@
+export declare const isAppInForeground: () => boolean;

package/lib/providers/pinpoint/utils/isAppInForeground.js

@@ -0,0 +1,7 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAppInForeground = void 0;
+const isAppInForeground = () => true;
+exports.isAppInForeground = isAppInForeground;

package/lib/providers/pinpoint/utils/isAppInForeground.native.d.ts

@@ -0,0 +1 @@
+export declare const isAppInForeground: () => boolean;