@azure/msal-browser 3.0.2 → 3.2.0

package/src/event/EventHandler.ts

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    ICrypto,
+    Logger,
+    AccountEntity,
+    CacheManager,
+} from "@azure/msal-common";
+import { InteractionType } from "../utils/BrowserConstants";
+import {
+    EventCallbackFunction,
+    EventError,
+    EventMessage,
+    EventPayload,
+} from "./EventMessage";
+import { EventType } from "./EventType";
+import { createNewGuid } from "../crypto/BrowserCrypto";
+
+export class EventHandler {
+    // Callback for subscribing to events
+    private eventCallbacks: Map<string, EventCallbackFunction>;
+    private logger: Logger;
+    private browserCrypto: ICrypto;
+    private listeningToStorageEvents: boolean;
+
+    constructor(logger: Logger, browserCrypto: ICrypto) {
+        this.eventCallbacks = new Map();
+        this.logger = logger;
+        this.browserCrypto = browserCrypto;
+        this.listeningToStorageEvents = false;
+        this.handleAccountCacheChange =
+            this.handleAccountCacheChange.bind(this);
+    }
+
+    /**
+     * Adds event callbacks to array
+     * @param callback
+     */
+    addEventCallback(callback: EventCallbackFunction): string | null {
+        if (typeof window !== "undefined") {
+            const callbackId = createNewGuid();
+            this.eventCallbacks.set(callbackId, callback);
+            this.logger.verbose(
+                `Event callback registered with id: ${callbackId}`
+            );
+
+            return callbackId;
+        }
+
+        return null;
+    }
+
+    /**
+     * Removes callback with provided id from callback array
+     * @param callbackId
+     */
+    removeEventCallback(callbackId: string): void {
+        this.eventCallbacks.delete(callbackId);
+        this.logger.verbose(`Event callback ${callbackId} removed.`);
+    }
+
+    /**
+     * Adds event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
+     */
+    enableAccountStorageEvents(): void {
+        if (typeof window === "undefined") {
+            return;
+        }
+
+        if (!this.listeningToStorageEvents) {
+            this.logger.verbose("Adding account storage listener.");
+            this.listeningToStorageEvents = true;
+            window.addEventListener("storage", this.handleAccountCacheChange);
+        } else {
+            this.logger.verbose("Account storage listener already registered.");
+        }
+    }
+
+    /**
+     * Removes event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
+     */
+    disableAccountStorageEvents(): void {
+        if (typeof window === "undefined") {
+            return;
+        }
+
+        if (this.listeningToStorageEvents) {
+            this.logger.verbose("Removing account storage listener.");
+            window.removeEventListener(
+                "storage",
+                this.handleAccountCacheChange
+            );
+            this.listeningToStorageEvents = false;
+        } else {
+            this.logger.verbose("No account storage listener registered.");
+        }
+    }
+
+    /**
+     * Emits events by calling callback with event message
+     * @param eventType
+     * @param interactionType
+     * @param payload
+     * @param error
+     */
+    emitEvent(
+        eventType: EventType,
+        interactionType?: InteractionType,
+        payload?: EventPayload,
+        error?: EventError
+    ): void {
+        if (typeof window !== "undefined") {
+            const message: EventMessage = {
+                eventType: eventType,
+                interactionType: interactionType || null,
+                payload: payload || null,
+                error: error || null,
+                timestamp: Date.now(),
+            };
+
+            this.logger.info(`Emitting event: ${eventType}`);
+
+            this.eventCallbacks.forEach(
+                (callback: EventCallbackFunction, callbackId: string) => {
+                    this.logger.verbose(
+                        `Emitting event to callback ${callbackId}: ${eventType}`
+                    );
+                    callback.apply(null, [message]);
+                }
+            );
+        }
+    }
+
+    /**
+     * Emit account added/removed events when cached accounts are changed in a different tab or frame
+     */
+    private handleAccountCacheChange(e: StorageEvent): void {
+        try {
+            const cacheValue = e.newValue || e.oldValue;
+            if (!cacheValue) {
+                return;
+            }
+            const parsedValue = JSON.parse(cacheValue);
+            if (
+                typeof parsedValue !== "object" ||
+                !AccountEntity.isAccountEntity(parsedValue)
+            ) {
+                return;
+            }
+            const accountEntity = CacheManager.toObject<AccountEntity>(
+                new AccountEntity(),
+                parsedValue
+            );
+            const accountInfo = accountEntity.getAccountInfo();
+            if (!e.oldValue && e.newValue) {
+                this.logger.info(
+                    "Account was added to cache in a different window"
+                );
+                this.emitEvent(EventType.ACCOUNT_ADDED, undefined, accountInfo);
+            } else if (!e.newValue && e.oldValue) {
+                this.logger.info(
+                    "Account was removed from cache in a different window"
+                );
+                this.emitEvent(
+                    EventType.ACCOUNT_REMOVED,
+                    undefined,
+                    accountInfo
+                );
+            }
+        } catch (e) {
+            return;
+        }
+    }
+}

package/src/event/EventMessage.ts

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthError, AccountInfo } from "@azure/msal-common";
+import { EventType } from "./EventType";
+import { InteractionStatus, InteractionType } from "../utils/BrowserConstants";
+import {
+    PopupRequest,
+    RedirectRequest,
+    SilentRequest,
+    SsoSilentRequest,
+    EndSessionRequest,
+    AuthenticationResult,
+} from "..";
+
+export type EventMessage = {
+    eventType: EventType;
+    interactionType: InteractionType | null;
+    payload: EventPayload;
+    error: EventError;
+    timestamp: number;
+};
+
+export type PopupEvent = {
+    popupWindow: Window;
+};
+
+export type EventPayload =
+    | AccountInfo
+    | PopupRequest
+    | RedirectRequest
+    | SilentRequest
+    | SsoSilentRequest
+    | EndSessionRequest
+    | AuthenticationResult
+    | PopupEvent
+    | null;
+
+export type EventError = AuthError | Error | null;
+
+export type EventCallbackFunction = (message: EventMessage) => void;
+
+export class EventMessageUtils {
+    /**
+     * Gets interaction status from event message
+     * @param message
+     * @param currentStatus
+     */
+    static getInteractionStatusFromEvent(
+        message: EventMessage,
+        currentStatus?: InteractionStatus
+    ): InteractionStatus | null {
+        switch (message.eventType) {
+            case EventType.LOGIN_START:
+                return InteractionStatus.Login;
+            case EventType.SSO_SILENT_START:
+                return InteractionStatus.SsoSilent;
+            case EventType.ACQUIRE_TOKEN_START:
+                if (
+                    message.interactionType === InteractionType.Redirect ||
+                    message.interactionType === InteractionType.Popup
+                ) {
+                    return InteractionStatus.AcquireToken;
+                }
+                break;
+            case EventType.HANDLE_REDIRECT_START:
+                return InteractionStatus.HandleRedirect;
+            case EventType.LOGOUT_START:
+                return InteractionStatus.Logout;
+            case EventType.SSO_SILENT_SUCCESS:
+            case EventType.SSO_SILENT_FAILURE:
+                if (
+                    currentStatus &&
+                    currentStatus !== InteractionStatus.SsoSilent
+                ) {
+                    // Prevent this event from clearing any status other than ssoSilent
+                    break;
+                }
+                return InteractionStatus.None;
+            case EventType.LOGOUT_END:
+                if (
+                    currentStatus &&
+                    currentStatus !== InteractionStatus.Logout
+                ) {
+                    // Prevent this event from clearing any status other than logout
+                    break;
+                }
+                return InteractionStatus.None;
+            case EventType.HANDLE_REDIRECT_END:
+                if (
+                    currentStatus &&
+                    currentStatus !== InteractionStatus.HandleRedirect
+                ) {
+                    // Prevent this event from clearing any status other than handleRedirect
+                    break;
+                }
+                return InteractionStatus.None;
+            case EventType.LOGIN_SUCCESS:
+            case EventType.LOGIN_FAILURE:
+            case EventType.ACQUIRE_TOKEN_SUCCESS:
+            case EventType.ACQUIRE_TOKEN_FAILURE:
+            case EventType.RESTORE_FROM_BFCACHE:
+                if (
+                    message.interactionType === InteractionType.Redirect ||
+                    message.interactionType === InteractionType.Popup
+                ) {
+                    if (
+                        currentStatus &&
+                        currentStatus !== InteractionStatus.Login &&
+                        currentStatus !== InteractionStatus.AcquireToken
+                    ) {
+                        // Prevent this event from clearing any status other than login or acquireToken
+                        break;
+                    }
+                    return InteractionStatus.None;
+                }
+                break;
+            default:
+                break;
+        }
+        return null;
+    }
+}

package/src/event/EventType.ts

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export const EventType = {
+    INITIALIZE_START: "msal:initializeStart",
+    INITIALIZE_END: "msal:initializeEnd",
+    ACCOUNT_ADDED: "msal:accountAdded",
+    ACCOUNT_REMOVED: "msal:accountRemoved",
+    LOGIN_START: "msal:loginStart",
+    LOGIN_SUCCESS: "msal:loginSuccess",
+    LOGIN_FAILURE: "msal:loginFailure",
+    ACQUIRE_TOKEN_START: "msal:acquireTokenStart",
+    ACQUIRE_TOKEN_SUCCESS: "msal:acquireTokenSuccess",
+    ACQUIRE_TOKEN_FAILURE: "msal:acquireTokenFailure",
+    ACQUIRE_TOKEN_NETWORK_START: "msal:acquireTokenFromNetworkStart",
+    SSO_SILENT_START: "msal:ssoSilentStart",
+    SSO_SILENT_SUCCESS: "msal:ssoSilentSuccess",
+    SSO_SILENT_FAILURE: "msal:ssoSilentFailure",
+    ACQUIRE_TOKEN_BY_CODE_START: "msal:acquireTokenByCodeStart",
+    ACQUIRE_TOKEN_BY_CODE_SUCCESS: "msal:acquireTokenByCodeSuccess",
+    ACQUIRE_TOKEN_BY_CODE_FAILURE: "msal:acquireTokenByCodeFailure",
+    HANDLE_REDIRECT_START: "msal:handleRedirectStart",
+    HANDLE_REDIRECT_END: "msal:handleRedirectEnd",
+    POPUP_OPENED: "msal:popupOpened",
+    LOGOUT_START: "msal:logoutStart",
+    LOGOUT_SUCCESS: "msal:logoutSuccess",
+    LOGOUT_FAILURE: "msal:logoutFailure",
+    LOGOUT_END: "msal:logoutEnd",
+    RESTORE_FROM_BFCACHE: "msal:restoreFromBFCache",
+} as const;
+export type EventType = (typeof EventType)[keyof typeof EventType];

package/src/index.ts

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * @packageDocumentation
+ * @module @azure/msal-browser
+ */
+
+/**
+ * Warning: This set of exports is purely intended to be used by other MSAL libraries, and should be considered potentially unstable. We strongly discourage using them directly, you do so at your own risk.
+ * Breaking changes to these APIs will be shipped under a minor version, instead of a major version.
+ */
+
+export { PublicClientApplication } from "./app/PublicClientApplication";
+export { IController } from "./controllers/IController";
+export {
+    Configuration,
+    BrowserAuthOptions,
+    CacheOptions,
+    BrowserSystemOptions,
+    BrowserTelemetryOptions,
+    BrowserConfiguration,
+    DEFAULT_IFRAME_TIMEOUT_MS,
+} from "./config/Configuration";
+export {
+    InteractionType,
+    InteractionStatus,
+    BrowserCacheLocation,
+    WrapperSKU,
+    ApiId,
+    CacheLookupPolicy,
+} from "./utils/BrowserConstants";
+export { BrowserUtils } from "./utils/BrowserUtils";
+
+/*
+ * export { IController} from "./controllers/IController";
+ * export { StandardController } from "./controllers/StandardController";
+ */
+
+// Browser Errors
+export {
+    BrowserAuthError,
+    BrowserAuthErrorMessage,
+    BrowserAuthErrorCodes,
+} from "./error/BrowserAuthError";
+export {
+    BrowserConfigurationAuthError,
+    BrowserConfigurationAuthErrorCodes,
+    BrowserConfigurationAuthErrorMessage,
+} from "./error/BrowserConfigurationAuthError";
+
+// Interfaces
+export {
+    IPublicClientApplication,
+    stubbedPublicClientApplication,
+} from "./app/IPublicClientApplication";
+export { INavigationClient } from "./navigation/INavigationClient";
+export { NavigationClient } from "./navigation/NavigationClient";
+export { NavigationOptions } from "./navigation/NavigationOptions";
+export { PopupRequest } from "./request/PopupRequest";
+export { RedirectRequest } from "./request/RedirectRequest";
+export { SilentRequest } from "./request/SilentRequest";
+export { SsoSilentRequest } from "./request/SsoSilentRequest";
+export { EndSessionRequest } from "./request/EndSessionRequest";
+export { EndSessionPopupRequest } from "./request/EndSessionPopupRequest";
+export { AuthorizationUrlRequest } from "./request/AuthorizationUrlRequest";
+export { AuthorizationCodeRequest } from "./request/AuthorizationCodeRequest";
+export { AuthenticationResult } from "./response/AuthenticationResult";
+export { ClearCacheRequest } from "./request/ClearCacheRequest";
+
+// Cache
+export { LoadTokenOptions } from "./cache/TokenCache";
+export { ITokenCache } from "./cache/ITokenCache";
+
+// Storage
+export { MemoryStorage } from "./cache/MemoryStorage";
+export { BrowserStorage } from "./cache/BrowserStorage";
+
+// Events
+export {
+    EventMessage,
+    EventPayload,
+    EventError,
+    EventCallbackFunction,
+    EventMessageUtils,
+    PopupEvent,
+} from "./event/EventMessage";
+export { EventType } from "./event/EventType";
+
+export {
+    SignedHttpRequest,
+    SignedHttpRequestOptions,
+} from "./crypto/SignedHttpRequest";
+
+export {
+    PopupWindowAttributes,
+    PopupSize,
+    PopupPosition,
+} from "./request/PopupWindowAttributes";
+
+// Telemetry
+export { BrowserPerformanceClient } from "./telemetry/BrowserPerformanceClient";
+export { BrowserPerformanceMeasurement } from "./telemetry/BrowserPerformanceMeasurement";
+
+// Common Object Formats
+export {
+    AuthenticationScheme,
+    // Account
+    AccountInfo,
+    AccountEntity,
+    IdTokenClaims,
+    // Error
+    AuthError,
+    AuthErrorCodes,
+    AuthErrorMessage,
+    ClientAuthError,
+    ClientAuthErrorCodes,
+    ClientAuthErrorMessage,
+    ClientConfigurationError,
+    ClientConfigurationErrorCodes,
+    ClientConfigurationErrorMessage,
+    InteractionRequiredAuthError,
+    InteractionRequiredAuthErrorCodes,
+    InteractionRequiredAuthErrorMessage,
+    ServerError,
+    // Network
+    INetworkModule,
+    NetworkResponse,
+    NetworkRequestOptions,
+    // Logger Object
+    ILoggerCallback,
+    Logger,
+    LogLevel,
+    // Protocol Mode
+    ProtocolMode,
+    ServerResponseType,
+    PromptValue,
+    // Server Response
+    ExternalTokenResponse,
+    // Utils
+    StringUtils,
+    UrlString,
+    // AzureCloudInstance enum
+    AzureCloudInstance,
+    AzureCloudOptions,
+    AuthenticationHeaderParser,
+    OIDC_DEFAULT_SCOPES,
+    PerformanceCallbackFunction,
+    PerformanceEvent,
+    PerformanceEvents,
+    // Telemetry
+    InProgressPerformanceEvent,
+} from "@azure/msal-common";
+
+export { version } from "./packageMetadata";