@aws-amplify/analytics 6.5.6-api-v6-models.b3abc9b.0 → 7.0.0

package/src/trackers/PageViewTracker.ts

@@ -1,157 +1,160 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { pageViewTrackOpts } from '../types';
-import { MethodEmbed } from '../utils/MethodEmbed';
-import { ConsoleLogger as Logger, browserOrNode } from '@aws-amplify/core';
-
-const logger = new Logger('PageViewTracker');
-const PREV_URL_KEY = 'aws-amplify-analytics-prevUrl';
-
-const getUrl = () => {
-	if (!browserOrNode().isBrowser) return '';
-	else return window.location.origin + window.location.pathname;
-};
-
-const defaultOpts: pageViewTrackOpts = {
-	enable: false,
-	provider: 'AWSPinpoint',
-	getUrl,
+import {
+	PageViewTrackingOptions,
+	TrackerEventRecorder,
+	TrackerInterface,
+} from '../types/trackers';
+import { ConsoleLogger } from '@aws-amplify/core';
+import { isBrowser } from '@aws-amplify/core/internals/utils';
+
+const logger = new ConsoleLogger('PageViewTracker');
+
+const DEFAULT_EVENT_NAME = 'pageView';
+const DEFAULT_APP_TYPE = 'singlePage';
+const DEFAULT_URL_PROVIDER = () => {
+	return window.location.origin + window.location.pathname;
 };
+const PREV_URL_STORAGE_KEY = 'aws-amplify-analytics-prevUrl';
+
+export class PageViewTracker implements TrackerInterface {
+	private trackerActive: boolean;
+	private options: PageViewTrackingOptions;
+	private eventRecorder: TrackerEventRecorder;
+
+	// SPA tracking helpers
+	private spaTrackingActive: boolean;
+	private pushStateProxy?: any;
+	private replaceStateProxy?: any;
+	private originalPushState: any;
+	private originalReplaceState: any;
+
+	constructor(
+		eventRecorder: TrackerEventRecorder,
+		options?: PageViewTrackingOptions
+	) {
+		this.options = {};
+		this.trackerActive = true;
+		this.eventRecorder = eventRecorder;
+		this.spaTrackingActive = false;
+		this.handleLocationChange = this.handleLocationChange.bind(this);
+
+		this.configure(eventRecorder, options);
+	}
 
-export class PageViewTracker {
-	private _config: pageViewTrackOpts;
-	private _tracker;
-	private _hasEnabled;
-
-	constructor(tracker, opts) {
-		logger.debug('initialize pageview tracker with opts', opts);
-		this._config = Object.assign({}, defaultOpts, opts);
-		this._tracker = tracker;
-		this._hasEnabled = false;
-		this._trackFunc = this._trackFunc.bind(this);
-
-		if (this._config.type === 'SPA') {
-			this._pageViewTrackSPA();
-		} else {
-			this._pageViewTrackDefault();
+	public configure(
+		eventRecorder: TrackerEventRecorder,
+		options?: PageViewTrackingOptions
+	) {
+		this.eventRecorder = eventRecorder;
+
+		// Clean up any existing listeners
+		this.cleanup();
+
+		// Apply defaults
+		this.options = {
+			appType: options?.appType ?? DEFAULT_APP_TYPE,
+			attributes: options?.attributes ?? undefined,
+			eventName: this.options?.eventName ?? DEFAULT_EVENT_NAME,
+			urlProvider: this.options?.urlProvider ?? DEFAULT_URL_PROVIDER,
+		};
+
+		// Configure SPA or MPA page view tracking
+		if (isBrowser()) {
+			if (this.options.appType === 'singlePage') {
+				this.setupSPATracking();
+			} else {
+				this.setupMPATracking();
+			}
+
+			this.trackerActive = true;
 		}
 	}
 
-	public configure(opts?: pageViewTrackOpts) {
-		Object.assign(this._config, opts);
-
-		// if spa, need to remove those listeners if disabled
-		if (this._config.type === 'SPA') {
-			this._pageViewTrackSPA();
+	public cleanup() {
+		// No-op if document listener is not active
+		if (!this.trackerActive) {
+			return;
 		}
 
-		return this._config;
+		// Clean up SPA page view listeners
+		if (this.spaTrackingActive) {
+			window.history.pushState = this.originalPushState;
+			window.history.replaceState = this.originalReplaceState;
+			this.pushStateProxy?.revoke();
+			this.replaceStateProxy?.revoke();
+			window.removeEventListener('popstate', this.handleLocationChange);
+
+			this.spaTrackingActive = false;
+		}
 	}
 
-	private _isSameUrl() {
-		const prevUrl = sessionStorage.getItem(PREV_URL_KEY);
-		const curUrl = this._config.getUrl();
+	private setupSPATracking() {
+		if (!this.spaTrackingActive) {
+			// Configure proxies on History APIs
+			this.pushStateProxy = Proxy.revocable(window.history.pushState, {
+				apply: (target, thisArg, args) => {
+					const proxiedResult = target.apply(thisArg, args as any);
 
-		if (prevUrl === curUrl) {
-			logger.debug('the url is same');
-			return true;
-		} else return false;
-	}
+					this.handleLocationChange();
 
-	private async _pageViewTrackDefault() {
-		if (
-			!browserOrNode().isBrowser ||
-			!window.addEventListener ||
-			!window.sessionStorage
-		) {
-			logger.debug('not in the supported web enviroment');
-			return;
-		}
-		const url = this._config.getUrl();
-		const customAttrs =
-			typeof this._config.attributes === 'function'
-				? await this._config.attributes()
-				: this._config.attributes;
-		const attributes = Object.assign(
-			{
-				url,
-			},
-			customAttrs
-		);
-
-		if (this._config.enable && !this._isSameUrl()) {
-			this._tracker(
-				{
-					name: this._config.eventName || 'pageView',
-					attributes,
+					return proxiedResult;
 				},
-				this._config.provider
-			).catch(e => {
-				logger.debug('Failed to record the page view event', e);
 			});
-			sessionStorage.setItem(PREV_URL_KEY, url);
+			this.replaceStateProxy = Proxy.revocable(window.history.replaceState, {
+				apply: (target, thisArg, args) => {
+					const proxiedResult = target.apply(thisArg, args as any);
+
+					this.handleLocationChange();
+
+					return proxiedResult;
+				},
+			});
+
+			this.originalPushState = window.history.pushState;
+			this.originalReplaceState = window.history.replaceState;
+			window.history.pushState = this.pushStateProxy.proxy;
+			window.history.replaceState = this.replaceStateProxy.proxy;
+			window.addEventListener('popstate', this.handleLocationChange);
+			sessionStorage.removeItem(PREV_URL_STORAGE_KEY);
+
+			this.spaTrackingActive = true;
 		}
 	}
 
-	private async _trackFunc() {
-		if (
-			!browserOrNode().isBrowser ||
-			!window.addEventListener ||
-			!history.pushState ||
-			!window.sessionStorage
-		) {
-			logger.debug('not in the supported web enviroment');
-			return;
-		}
+	private setupMPATracking() {
+		this.handleLocationChange();
+	}
 
-		const url = this._config.getUrl();
-		const customAttrs =
-			typeof this._config.attributes === 'function'
-				? await this._config.attributes()
-				: this._config.attributes;
-		const attributes = Object.assign(
-			{
-				url,
-			},
-			customAttrs
-		);
-
-		if (!this._isSameUrl()) {
-			this._tracker(
+	private handleLocationChange() {
+		const currentUrl = this.options.urlProvider!();
+		const eventName = this.options.eventName || DEFAULT_EVENT_NAME;
+
+		if (this.urlHasChanged()) {
+			sessionStorage.setItem(PREV_URL_STORAGE_KEY, currentUrl);
+
+			// Assemble attribute list
+			const attributes = Object.assign(
 				{
-					name: this._config.eventName || 'pageView',
-					attributes,
+					url: currentUrl,
 				},
-				this._config.provider
-			).catch(e => {
-				logger.debug('Failed to record the page view event', e);
+				this.options.attributes
+			);
+
+			logger.debug('Recording automatically tracked page view event', {
+				eventName,
+				attributes,
 			});
-			sessionStorage.setItem(PREV_URL_KEY, url);
+
+			this.eventRecorder(eventName, attributes);
 		}
 	}
 
-	private _pageViewTrackSPA() {
-		if (
-			!browserOrNode().isBrowser ||
-			!window.addEventListener ||
-			!history.pushState
-		) {
-			logger.debug('not in the supported web enviroment');
-			return;
-		}
+	private urlHasChanged() {
+		const prevUrl = sessionStorage.getItem(PREV_URL_STORAGE_KEY);
+		const currUrl = this.options.urlProvider!();
 
-		if (this._config.enable && !this._hasEnabled) {
-			MethodEmbed.add(history, 'pushState', this._trackFunc);
-			MethodEmbed.add(history, 'replaceState', this._trackFunc);
-			window.addEventListener('popstate', this._trackFunc);
-			this._trackFunc();
-			this._hasEnabled = true;
-		} else {
-			MethodEmbed.remove(history, 'pushState');
-			MethodEmbed.remove(history, 'replaceState');
-			window.removeEventListener('popstate', this._trackFunc);
-			this._hasEnabled = false;
-		}
+		return currUrl !== prevUrl;
 	}
 }

package/src/trackers/SessionTracker.native.ts

@@ -0,0 +1,105 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	sessionListener,
+	SessionState,
+	SESSION_START_EVENT,
+	SESSION_STOP_EVENT,
+} from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+import {
+	SessionTrackingOptions,
+	TrackerEventRecorder,
+	TrackerInterface,
+} from '../types/trackers';
+
+const logger = new ConsoleLogger('SessionTracker');
+
+export class SessionTracker implements TrackerInterface {
+	private options: SessionTrackingOptions;
+	private eventRecorder: TrackerEventRecorder;
+	private initialEventSent: boolean;
+	private sessionTrackingActive: boolean;
+
+	constructor(
+		eventRecorder: TrackerEventRecorder,
+		options?: SessionTrackingOptions
+	) {
+		this.options = {};
+		this.eventRecorder = eventRecorder;
+		this.initialEventSent = false;
+		this.sessionTrackingActive = false;
+		this.handleStateChange = this.handleStateChange.bind(this);
+
+		this.configure(eventRecorder, options);
+	}
+
+	public configure(
+		eventRecorder: TrackerEventRecorder,
+		options?: SessionTrackingOptions
+	) {
+		this.eventRecorder = eventRecorder;
+
+		// Clean up any existing listeners
+		this.cleanup();
+
+		// Apply defaults
+		this.options = {
+			attributes: options?.attributes ?? {},
+		};
+
+		// Setup state listeners
+		if (!this.sessionTrackingActive) {
+			sessionListener.addStateChangeListener(
+				this.handleStateChange,
+				!this.initialEventSent
+			);
+
+			this.sessionTrackingActive = true;
+		}
+	}
+
+	public cleanup() {
+		if (this.sessionTrackingActive) {
+			sessionListener.removeStateChangeListener(this.handleStateChange);
+		}
+
+		this.sessionTrackingActive = false;
+	}
+
+	private handleStateChange(state: SessionState) {
+		if (state === 'started') {
+			this.sessionStarted();
+		} else {
+			this.sessionStopped();
+		}
+	}
+
+	private sessionStarted() {
+		const attributes = this.options.attributes ?? {};
+
+		logger.debug('Recording automatically tracked page view event', {
+			SESSION_START_EVENT,
+			attributes,
+		});
+
+		this.eventRecorder(SESSION_START_EVENT, attributes);
+
+		// NOTE: The initial event will not be re-sent on re-configuration (e.g. to add additional custom attributes)
+		if (!this.initialEventSent) {
+			this.initialEventSent = true;
+		}
+	}
+
+	private sessionStopped() {
+		const attributes = this.options.attributes ?? {};
+
+		logger.debug('Recording automatically tracked page view event', {
+			SESSION_STOP_EVENT,
+			attributes,
+		});
+
+		this.eventRecorder(SESSION_STOP_EVENT, attributes);
+	}
+}

package/src/trackers/SessionTracker.ts

@@ -1,179 +1,105 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-// the session tracker for web
-
 import {
-	ConsoleLogger as Logger,
-	Hub,
-	Constants,
-	browserOrNode,
-} from '@aws-amplify/core';
-import { SessionTrackOpts } from '../types';
-
-const logger = new Logger('SessionTracker');
-
-const defaultOpts: SessionTrackOpts = {
-	enable: false,
-	provider: 'AWSPinpoint',
-};
-
-let initialEventSent = false;
-
-export class SessionTracker {
-	private _tracker;
-	private _hasEnabled;
-	private _config: SessionTrackOpts;
-
-	private _hidden;
-	private _visibilityChange;
-
-	constructor(tracker, opts) {
-		this._config = Object.assign({}, defaultOpts, opts);
-		this._tracker = tracker;
-
-		this._hasEnabled = false;
-		this._trackFunc = this._trackFunc.bind(this);
-		this._trackBeforeUnload = this._trackBeforeUnload.bind(this);
-
-		this.configure(this._config);
+	sessionListener,
+	SessionState,
+	SESSION_START_EVENT,
+	SESSION_STOP_EVENT,
+} from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+import {
+	SessionTrackingOptions,
+	TrackerEventRecorder,
+	TrackerInterface,
+} from '../types/trackers';
+
+const logger = new ConsoleLogger('SessionTracker');
+
+export class SessionTracker implements TrackerInterface {
+	private options: SessionTrackingOptions;
+	private eventRecorder: TrackerEventRecorder;
+	private sessionTrackingActive: boolean;
+	private initialEventSent: boolean;
+
+	constructor(
+		eventRecorder: TrackerEventRecorder,
+		options?: SessionTrackingOptions
+	) {
+		this.options = {};
+		this.eventRecorder = eventRecorder;
+		this.sessionTrackingActive = false;
+		this.initialEventSent = false;
+		this.handleStateChange = this.handleStateChange.bind(this);
+
+		this.configure(eventRecorder, options);
 	}
 
-	private _envCheck() {
-		if (!browserOrNode().isBrowser) {
-			return false;
-		}
+	public configure(
+		eventRecorder: TrackerEventRecorder,
+		options?: SessionTrackingOptions
+	) {
+		this.eventRecorder = eventRecorder;
+
+		// Clean up any existing listeners
+		this.cleanup();
+
+		// Apply defaults
+		this.options = {
+			attributes: options?.attributes ?? {},
+		};
+
+		// Setup state listeners
+		if (!this.sessionTrackingActive) {
+			sessionListener.addStateChangeListener(
+				this.handleStateChange,
+				!this.initialEventSent
+			);
 
-		if (!document || !document.addEventListener) {
-			logger.debug('not in the supported web environment');
-			return false;
+			this.sessionTrackingActive = true;
 		}
+	}
 
-		if (typeof document.hidden !== 'undefined') {
-			this._hidden = 'hidden';
-			this._visibilityChange = 'visibilitychange';
-		} else if (typeof document['msHidden'] !== 'undefined') {
-			this._hidden = 'msHidden';
-			this._visibilityChange = 'msvisibilitychange';
-		} else if (typeof document['webkitHidden'] !== 'undefined') {
-			this._hidden = 'webkitHidden';
-			this._visibilityChange = 'webkitvisibilitychange';
-		} else {
-			logger.debug('not in the supported web environment');
-			return false;
+	public cleanup() {
+		if (this.sessionTrackingActive) {
+			sessionListener.removeStateChangeListener(this.handleStateChange);
 		}
-		return true;
+
+		this.sessionTrackingActive = false;
 	}
 
-	private async _trackFunc() {
-		const customAttrs =
-			typeof this._config.attributes === 'function'
-				? await this._config.attributes()
-				: this._config.attributes;
-
-		const attributes = Object.assign({}, customAttrs);
-
-		if (document.visibilityState === this._hidden) {
-			this._tracker(
-				{
-					name: '_session.stop',
-					attributes,
-				},
-				this._config.provider
-			).catch(e => {
-				logger.debug('record session stop event failed.', e);
-			});
+	private handleStateChange(state: SessionState) {
+		if (state === 'started') {
+			this.sessionStarted();
 		} else {
-			this._tracker(
-				{
-					name: '_session.start',
-					attributes,
-				},
-				this._config.provider
-			).catch(e => {
-				logger.debug('record session start event failed.', e);
-			});
+			this.sessionStopped();
 		}
 	}
 
-	private _trackBeforeUnload(event) {
-		// before unload callback cannot be async => https://github.com/aws-amplify/amplify-js/issues/2088
-
-		const customAttrs =
-			typeof this._config.attributes === 'function'
-				? Promise.resolve(this._config.attributes())
-				: Promise.resolve(this._config.attributes);
-
-		customAttrs.then(custom => {
-			const attributes = Object.assign({}, custom);
-
-			this._tracker(
-				{
-					name: '_session.stop',
-					attributes,
-					immediate: true,
-				},
-				this._config.provider
-			).catch(e => {
-				logger.debug('record session stop event failed.', e);
-			});
+	private sessionStarted() {
+		const attributes = this.options.attributes ?? {};
+
+		logger.debug('Recording automatically tracked page view event', {
+			SESSION_START_EVENT,
+			attributes,
 		});
-	}
 
-	// to keep configure a synchronized function
-	private async _sendInitialEvent() {
-		if (initialEventSent) {
-			logger.debug('the start session has been sent when the page is loaded');
-			return;
-		} else {
-			initialEventSent = true;
-		}
+		this.eventRecorder(SESSION_START_EVENT, attributes);
 
-		const customAttrs =
-			typeof this._config.attributes === 'function'
-				? await this._config.attributes()
-				: this._config.attributes;
-
-		const attributes = Object.assign({}, customAttrs);
-
-		this._tracker(
-			{
-				name: '_session.start',
-				attributes,
-			},
-			this._config.provider
-		).catch(e => {
-			logger.debug('record session start event failed.', e);
-		});
+		// NOTE: The initial event will not be re-sent on re-configuration (e.g. to add additional custom attributes)
+		if (!this.initialEventSent) {
+			this.initialEventSent = true;
+		}
 	}
 
-	configure(opts?: SessionTrackOpts) {
-		if (!this._envCheck()) {
-			return this._config;
-		}
+	private sessionStopped() {
+		const attributes = this.options.attributes ?? {};
 
-		Object.assign(this._config, opts);
-		if (this._config.enable && !this._hasEnabled) {
-			// send a start session as soon as it's enabled
-			this._sendInitialEvent();
-			// listen on events
-			document.addEventListener(this._visibilityChange, this._trackFunc, false);
-			window.addEventListener('beforeunload', this._trackBeforeUnload, false);
-			this._hasEnabled = true;
-		} else if (!this._config.enable && this._hasEnabled) {
-			document.removeEventListener(
-				this._visibilityChange,
-				this._trackFunc,
-				false
-			);
-			window.removeEventListener(
-				'beforeunload',
-				this._trackBeforeUnload,
-				false
-			);
-			this._hasEnabled = false;
-		}
+		logger.debug('Recording automatically tracked page view event', {
+			SESSION_STOP_EVENT,
+			attributes,
+		});
 
-		return this._config;
+		this.eventRecorder(SESSION_STOP_EVENT, attributes);
 	}
 }

package/src/trackers/index.ts

@@ -1,5 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export { PageViewTracker } from './PageViewTracker';
+
 export { EventTracker } from './EventTracker';
+export { PageViewTracker } from './PageViewTracker';
 export { SessionTracker } from './SessionTracker';

package/src/types/index.ts

@@ -1,6 +1,11 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export * from './Analytics';
-export * from './Provider';
-export * from './Providers';
+export { AnalyticsServiceOptions } from './options';
+
+export {
+	AnalyticsConfigureAutoTrackInput,
+	AnalyticsIdentifyUserInput,
+} from './inputs';
+
+export { KinesisStream, KinesisShard, KinesisEventData } from './kinesis';