@aws-amplify/analytics 7.0.1-api-v6-models.9351bcf.0 → 7.0.1-api-v6-models.891fe0d.0

package/lib-esm/providers/kinesis/utils/resolveConfig.js

@@ -1,20 +1,21 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __assign } from "tslib";
 import { Amplify } from '@aws-amplify/core';
 import { AnalyticsValidationErrorCode, assertValidationError, } from '../../../errors';
 import { DEFAULT_KINESIS_CONFIG } from './constants';
-export var resolveConfig = function () {
-    var _a;
-    var config = (_a = Amplify.getConfig().Analytics) === null || _a === void 0 ? void 0 : _a.Kinesis;
-    var _b = __assign(__assign({}, DEFAULT_KINESIS_CONFIG), config), region = _b.region, _c = _b.bufferSize, bufferSize = _c === void 0 ? DEFAULT_KINESIS_CONFIG.bufferSize : _c, _d = _b.flushSize, flushSize = _d === void 0 ? DEFAULT_KINESIS_CONFIG.flushSize : _d, _e = _b.flushInterval, flushInterval = _e === void 0 ? DEFAULT_KINESIS_CONFIG.flushInterval : _e, resendLimit = _b.resendLimit;
+export const resolveConfig = () => {
+    const config = Amplify.getConfig().Analytics?.Kinesis;
+    const { region, bufferSize = DEFAULT_KINESIS_CONFIG.bufferSize, flushSize = DEFAULT_KINESIS_CONFIG.flushSize, flushInterval = DEFAULT_KINESIS_CONFIG.flushInterval, resendLimit, } = {
+        ...DEFAULT_KINESIS_CONFIG,
+        ...config,
+    };
     assertValidationError(!!region, AnalyticsValidationErrorCode.NoRegion);
     assertValidationError(flushSize < bufferSize, AnalyticsValidationErrorCode.InvalidFlushSize);
     return {
-        region: region,
-        bufferSize: bufferSize,
-        flushSize: flushSize,
-        flushInterval: flushInterval,
-        resendLimit: resendLimit,
+        region,
+        bufferSize,
+        flushSize,
+        flushInterval,
+        resendLimit,
     };
 };

package/lib-esm/providers/kinesis-firehose/apis/flushEvents.js

@@ -4,7 +4,7 @@ import { getEventBuffer, resolveConfig } from '../utils';
 import { getAnalyticsUserAgentString, resolveCredentials, } from '../../../utils';
 import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
-var logger = new ConsoleLogger('KinesisFirehose');
+const logger = new ConsoleLogger('KinesisFirehose');
 /**
  * Flushes all buffered Kinesis events to the service.
  *
@@ -12,22 +12,19 @@ var logger = new ConsoleLogger('KinesisFirehose');
  * This API will make a best-effort attempt to flush events from the buffer. Events recorded immediately after invoking
  * this API may not be included in the flush.
  */
-export var flushEvents = function () {
-    var _a = resolveConfig(), region = _a.region, flushSize = _a.flushSize, flushInterval = _a.flushInterval, bufferSize = _a.bufferSize, resendLimit = _a.resendLimit;
+export const flushEvents = () => {
+    const { region, flushSize, flushInterval, bufferSize, resendLimit } = resolveConfig();
     resolveCredentials()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        return getEventBuffer({
-            region: region,
-            flushSize: flushSize,
-            flushInterval: flushInterval,
-            bufferSize: bufferSize,
-            credentials: credentials,
-            identityId: identityId,
-            resendLimit: resendLimit,
-            userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
-        });
-    })
-        .then(function (eventBuffer) { return eventBuffer.flushAll(); })
-        .catch(function (e) { return logger.warn('Failed to flush events.', e); });
+        .then(({ credentials, identityId }) => getEventBuffer({
+        region,
+        flushSize,
+        flushInterval,
+        bufferSize,
+        credentials,
+        identityId,
+        resendLimit,
+        userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+    }))
+        .then(eventBuffer => eventBuffer.flushAll())
+        .catch(e => logger.warn('Failed to flush events.', e));
 };

package/lib-esm/providers/kinesis-firehose/apis/record.js

@@ -5,37 +5,35 @@ import { getAnalyticsUserAgentString, isAnalyticsEnabled, resolveCredentials, }
 import { fromUtf8 } from '@smithy/util-utf8';
 import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
-var logger = new ConsoleLogger('KinesisFirehose');
-export var record = function (_a) {
-    var streamName = _a.streamName, data = _a.data;
+const logger = new ConsoleLogger('KinesisFirehose');
+export const record = ({ streamName, data }) => {
     if (!isAnalyticsEnabled()) {
         logger.debug('Analytics is disabled, event will not be recorded.');
         return;
     }
-    var timestamp = Date.now();
-    var _b = resolveConfig(), region = _b.region, bufferSize = _b.bufferSize, flushSize = _b.flushSize, flushInterval = _b.flushInterval, resendLimit = _b.resendLimit;
+    const timestamp = Date.now();
+    const { region, bufferSize, flushSize, flushInterval, resendLimit } = resolveConfig();
     resolveCredentials()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        var buffer = getEventBuffer({
-            region: region,
-            credentials: credentials,
-            identityId: identityId,
-            bufferSize: bufferSize,
-            flushSize: flushSize,
-            flushInterval: flushInterval,
-            resendLimit: resendLimit,
+        .then(({ credentials, identityId }) => {
+        const buffer = getEventBuffer({
+            region,
+            credentials,
+            identityId,
+            bufferSize,
+            flushSize,
+            flushInterval,
+            resendLimit,
             userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
         });
         buffer.append({
-            region: region,
-            streamName: streamName,
+            region,
+            streamName,
             event: ArrayBuffer.isView(data) ? data : fromUtf8(JSON.stringify(data)),
-            timestamp: timestamp,
+            timestamp,
             retryCount: 0,
         });
     })
-        .catch(function (e) {
+        .catch(e => {
         logger.warn('Failed to record event.', e);
     });
 };

package/lib-esm/providers/kinesis-firehose/utils/constants.js

@@ -1,6 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export var DEFAULT_KINESIS_FIREHOSE_CONFIG = {
+export const DEFAULT_KINESIS_FIREHOSE_CONFIG = {
     bufferSize: 1000,
     flushSize: 100,
     flushInterval: 5000,

package/lib-esm/providers/kinesis-firehose/utils/getEventBuffer.js

@@ -1,6 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __assign, __awaiter, __generator, __read, __values } from "tslib";
 import { EventBuffer, groupBy } from '../../../utils';
 import { FirehoseClient, PutRecordBatchCommand, } from '@aws-sdk/client-firehose';
 /**
@@ -11,85 +10,57 @@ import { FirehoseClient, PutRecordBatchCommand, } from '@aws-sdk/client-firehose
  * Only one active session should exist at any given moment.
  * When a new session is initiated, the previous ones should be released.
  * */
-var eventBufferMap = {};
-var cachedClients = {};
-var createPutRecordsBatchCommand = function (streamName, events) {
-    return new PutRecordBatchCommand({
-        DeliveryStreamName: streamName,
-        Records: events.map(function (event) { return ({
-            Data: event.event,
-        }); }),
-    });
+const eventBufferMap = {};
+const cachedClients = {};
+const createPutRecordsBatchCommand = (streamName, events) => new PutRecordBatchCommand({
+    DeliveryStreamName: streamName,
+    Records: events.map(event => ({
+        Data: event.event,
+    })),
+});
+const submitEvents = async (events, client, resendLimit) => {
+    const groupedByStreamName = Object.entries(groupBy(event => event.streamName, events));
+    const requests = groupedByStreamName
+        .map(([streamName, events]) => createPutRecordsBatchCommand(streamName, events))
+        .map(command => client.send(command));
+    const responses = await Promise.allSettled(requests);
+    const failedEvents = responses
+        .map((response, i) => response.status === 'rejected' ? groupedByStreamName[i][1] : [])
+        .flat();
+    return resendLimit
+        ? failedEvents
+            .filter(event => event.retryCount < resendLimit)
+            .map(event => ({ ...event, retryCount: event.retryCount + 1 }))
+            .sort((a, b) => a.timestamp - b.timestamp)
+        : [];
 };
-var submitEvents = function (events, client, resendLimit) { return __awaiter(void 0, void 0, void 0, function () {
-    var groupedByStreamName, requests, responses, failedEvents;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                groupedByStreamName = Object.entries(groupBy(function (event) { return event.streamName; }, events));
-                requests = groupedByStreamName
-                    .map(function (_a) {
-                    var _b = __read(_a, 2), streamName = _b[0], events = _b[1];
-                    return createPutRecordsBatchCommand(streamName, events);
-                })
-                    .map(function (command) { return client.send(command); });
-                return [4 /*yield*/, Promise.allSettled(requests)];
-            case 1:
-                responses = _a.sent();
-                failedEvents = responses
-                    .map(function (response, i) {
-                    return response.status === 'rejected' ? groupedByStreamName[i][1] : [];
-                })
-                    .flat();
-                return [2 /*return*/, resendLimit
-                        ? failedEvents
-                            .filter(function (event) { return event.retryCount < resendLimit; })
-                            .map(function (event) { return (__assign(__assign({}, event), { retryCount: event.retryCount + 1 })); })
-                            .sort(function (a, b) { return a.timestamp - b.timestamp; })
-                        : []];
-        }
-    });
-}); };
-export var getEventBuffer = function (_a) {
-    var e_1, _b;
-    var region = _a.region, credentials = _a.credentials, identityId = _a.identityId, bufferSize = _a.bufferSize, flushSize = _a.flushSize, flushInterval = _a.flushInterval, resendLimit = _a.resendLimit, userAgentValue = _a.userAgentValue;
-    var sessionToken = credentials.sessionToken;
-    var sessionIdentityKey = [region, sessionToken, identityId]
-        .filter(function (id) { return !!id; })
-        .join('-');
+export const getEventBuffer = ({ region, credentials, identityId, bufferSize, flushSize, flushInterval, resendLimit, userAgentValue, }) => {
+    const sessionIdentityKey = [region, identityId].filter(id => !!id).join('-');
     if (!eventBufferMap[sessionIdentityKey]) {
-        var getClient = function () {
+        const getClient = () => {
             if (!cachedClients[sessionIdentityKey]) {
                 cachedClients[sessionIdentityKey] = new FirehoseClient({
-                    region: region,
-                    credentials: credentials,
+                    region,
+                    credentials,
                     customUserAgent: userAgentValue,
                 });
             }
-            var firehoseClient = cachedClients[sessionIdentityKey];
-            return function (events) { return submitEvents(events, firehoseClient, resendLimit); };
+            const firehoseClient = cachedClients[sessionIdentityKey];
+            return events => submitEvents(events, firehoseClient, resendLimit);
         };
         eventBufferMap[sessionIdentityKey] =
             new EventBuffer({
-                bufferSize: bufferSize,
-                flushSize: flushSize,
-                flushInterval: flushInterval,
+                bufferSize,
+                flushSize,
+                flushInterval,
             }, getClient);
-        var releaseSessionKeys = Object.keys(eventBufferMap).filter(function (key) { return key !== sessionIdentityKey; });
-        try {
-            for (var releaseSessionKeys_1 = __values(releaseSessionKeys), releaseSessionKeys_1_1 = releaseSessionKeys_1.next(); !releaseSessionKeys_1_1.done; releaseSessionKeys_1_1 = releaseSessionKeys_1.next()) {
-                var releaseSessionKey = releaseSessionKeys_1_1.value;
+        const releaseSessionKeys = Object.keys(eventBufferMap).filter(key => key !== sessionIdentityKey);
+        for (const releaseSessionKey of releaseSessionKeys) {
+            eventBufferMap[releaseSessionKey].flushAll().finally(() => {
                 eventBufferMap[releaseSessionKey].release();
                 delete eventBufferMap[releaseSessionKey];
                 delete cachedClients[releaseSessionKey];
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (releaseSessionKeys_1_1 && !releaseSessionKeys_1_1.done && (_b = releaseSessionKeys_1.return)) _b.call(releaseSessionKeys_1);
-            }
-            finally { if (e_1) throw e_1.error; }
+            });
         }
     }
     return eventBufferMap[sessionIdentityKey];

package/lib-esm/providers/kinesis-firehose/utils/resolveConfig.js

@@ -1,20 +1,21 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __assign } from "tslib";
 import { Amplify } from '@aws-amplify/core';
 import { AnalyticsValidationErrorCode, assertValidationError, } from '../../../errors';
 import { DEFAULT_KINESIS_FIREHOSE_CONFIG } from './constants';
-export var resolveConfig = function () {
-    var _a;
-    var config = (_a = Amplify.getConfig().Analytics) === null || _a === void 0 ? void 0 : _a.KinesisFirehose;
-    var _b = __assign(__assign({}, DEFAULT_KINESIS_FIREHOSE_CONFIG), config), region = _b.region, _c = _b.bufferSize, bufferSize = _c === void 0 ? DEFAULT_KINESIS_FIREHOSE_CONFIG.bufferSize : _c, _d = _b.flushSize, flushSize = _d === void 0 ? DEFAULT_KINESIS_FIREHOSE_CONFIG.flushSize : _d, _e = _b.flushInterval, flushInterval = _e === void 0 ? DEFAULT_KINESIS_FIREHOSE_CONFIG.flushInterval : _e, resendLimit = _b.resendLimit;
+export const resolveConfig = () => {
+    const config = Amplify.getConfig().Analytics?.KinesisFirehose;
+    const { region, bufferSize = DEFAULT_KINESIS_FIREHOSE_CONFIG.bufferSize, flushSize = DEFAULT_KINESIS_FIREHOSE_CONFIG.flushSize, flushInterval = DEFAULT_KINESIS_FIREHOSE_CONFIG.flushInterval, resendLimit, } = {
+        ...DEFAULT_KINESIS_FIREHOSE_CONFIG,
+        ...config,
+    };
     assertValidationError(!!region, AnalyticsValidationErrorCode.NoRegion);
     assertValidationError(flushSize < bufferSize, AnalyticsValidationErrorCode.InvalidFlushSize);
     return {
-        region: region,
-        bufferSize: bufferSize,
-        flushSize: flushSize,
-        flushInterval: flushInterval,
-        resendLimit: resendLimit,
+        region,
+        bufferSize,
+        flushSize,
+        flushInterval,
+        resendLimit,
     };
 };

package/lib-esm/providers/personalize/apis/flushEvents.js

@@ -4,7 +4,7 @@ import { getEventBuffer, resolveConfig } from '../utils';
 import { getAnalyticsUserAgentString, resolveCredentials, } from '../../../utils';
 import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
-var logger = new ConsoleLogger('Personalize');
+const logger = new ConsoleLogger('Personalize');
 /**
  * Flushes all buffered Personalize events to the service.
  *
@@ -12,21 +12,18 @@ var logger = new ConsoleLogger('Personalize');
  * This API will make a best-effort attempt to flush events from the buffer. Events recorded immediately after invoking
  * this API may not be included in the flush.
  */
-export var flushEvents = function () {
-    var _a = resolveConfig(), region = _a.region, flushSize = _a.flushSize, bufferSize = _a.bufferSize, flushInterval = _a.flushInterval;
+export const flushEvents = () => {
+    const { region, flushSize, bufferSize, flushInterval } = resolveConfig();
     resolveCredentials()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        return getEventBuffer({
-            region: region,
-            flushSize: flushSize,
-            flushInterval: flushInterval,
-            bufferSize: bufferSize,
-            credentials: credentials,
-            identityId: identityId,
-            userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
-        });
-    })
-        .then(function (eventBuffer) { return eventBuffer.flushAll(); })
-        .catch(function (e) { return logger.warn('Failed to flush events', e); });
+        .then(({ credentials, identityId }) => getEventBuffer({
+        region,
+        flushSize,
+        flushInterval,
+        bufferSize,
+        credentials,
+        identityId,
+        userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
+    }))
+        .then(eventBuffer => eventBuffer.flushAll())
+        .catch(e => logger.warn('Failed to flush events', e));
 };

package/lib-esm/providers/personalize/apis/record.js

@@ -1,83 +1,67 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { __awaiter, __generator } from "tslib";
 import { autoTrackMedia, getEventBuffer, resolveCachedSession, resolveConfig, updateCachedSession, } from '../utils';
 import { getAnalyticsUserAgentString, isAnalyticsEnabled, resolveCredentials, } from '../../../utils';
 import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
 import { ConsoleLogger } from '@aws-amplify/core';
 import { IDENTIFY_EVENT_TYPE, MEDIA_AUTO_TRACK_EVENT_TYPE, } from '../utils/constants';
-var logger = new ConsoleLogger('Personalize');
-export var record = function (_a) {
-    var userId = _a.userId, eventId = _a.eventId, eventType = _a.eventType, properties = _a.properties;
+const logger = new ConsoleLogger('Personalize');
+export const record = ({ userId, eventId, eventType, properties, }) => {
     if (!isAnalyticsEnabled()) {
         logger.debug('Analytics is disabled, event will not be recorded.');
         return;
     }
-    var _b = resolveConfig(), region = _b.region, trackingId = _b.trackingId, bufferSize = _b.bufferSize, flushSize = _b.flushSize, flushInterval = _b.flushInterval;
+    const { region, trackingId, bufferSize, flushSize, flushInterval } = resolveConfig();
     resolveCredentials()
-        .then(function (_a) {
-        var credentials = _a.credentials, identityId = _a.identityId;
-        return __awaiter(void 0, void 0, void 0, function () {
-            var timestamp, _b, cachedSessionId, cachedUserId, _c, updatedSessionId, updatedUserId, eventBuffer;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        timestamp = Date.now();
-                        return [4 /*yield*/, resolveCachedSession()];
-                    case 1:
-                        _b = _d.sent(), cachedSessionId = _b.sessionId, cachedUserId = _b.userId;
-                        if (eventType === IDENTIFY_EVENT_TYPE) {
-                            updateCachedSession(typeof properties.userId === 'string' ? properties.userId : '', cachedSessionId, cachedUserId);
-                        }
-                        else if (!!userId) {
-                            updateCachedSession(userId, cachedSessionId, cachedUserId);
-                        }
-                        return [4 /*yield*/, resolveCachedSession()];
-                    case 2:
-                        _c = _d.sent(), updatedSessionId = _c.sessionId, updatedUserId = _c.userId;
-                        eventBuffer = getEventBuffer({
-                            region: region,
-                            flushSize: flushSize,
-                            flushInterval: flushInterval,
-                            bufferSize: bufferSize,
-                            credentials: credentials,
-                            identityId: identityId,
-                            userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
-                        });
-                        if (eventType === MEDIA_AUTO_TRACK_EVENT_TYPE) {
-                            autoTrackMedia({
-                                trackingId: trackingId,
-                                sessionId: updatedSessionId,
-                                userId: updatedUserId,
-                                event: {
-                                    eventId: eventId,
-                                    eventType: eventType,
-                                    properties: properties,
-                                },
-                            }, eventBuffer);
-                        }
-                        else {
-                            eventBuffer.append({
-                                trackingId: trackingId,
-                                sessionId: updatedSessionId,
-                                userId: updatedUserId,
-                                event: {
-                                    eventId: eventId,
-                                    eventType: eventType,
-                                    properties: properties,
-                                },
-                                timestamp: timestamp,
-                            });
-                        }
-                        if (eventBuffer.length >= bufferSize) {
-                            eventBuffer.flushAll();
-                        }
-                        return [2 /*return*/];
-                }
-            });
+        .then(async ({ credentials, identityId }) => {
+        const timestamp = Date.now();
+        const { sessionId: cachedSessionId, userId: cachedUserId } = await resolveCachedSession();
+        if (eventType === IDENTIFY_EVENT_TYPE) {
+            updateCachedSession(typeof properties.userId === 'string' ? properties.userId : '', cachedSessionId, cachedUserId);
+        }
+        else if (!!userId) {
+            updateCachedSession(userId, cachedSessionId, cachedUserId);
+        }
+        const { sessionId: updatedSessionId, userId: updatedUserId } = await resolveCachedSession();
+        const eventBuffer = getEventBuffer({
+            region,
+            flushSize,
+            flushInterval,
+            bufferSize,
+            credentials,
+            identityId,
+            userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.Record),
         });
+        if (eventType === MEDIA_AUTO_TRACK_EVENT_TYPE) {
+            autoTrackMedia({
+                trackingId,
+                sessionId: updatedSessionId,
+                userId: updatedUserId,
+                event: {
+                    eventId,
+                    eventType,
+                    properties,
+                },
+            }, eventBuffer);
+        }
+        else {
+            eventBuffer.append({
+                trackingId,
+                sessionId: updatedSessionId,
+                userId: updatedUserId,
+                event: {
+                    eventId,
+                    eventType,
+                    properties,
+                },
+                timestamp,
+            });
+        }
+        if (eventBuffer.length >= bufferSize) {
+            eventBuffer.flushAll();
+        }
     })
-        .catch(function (e) {
+        .catch(e => {
         logger.warn('Failed to record event.', e);
     });
 };