@azure/msal-browser 3.0.2 → 3.1.0

package/src/error/NativeAuthError.ts

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthError, InteractionRequiredAuthError } from "@azure/msal-common";
+import {
+    createBrowserAuthError,
+    BrowserAuthErrorCodes,
+} from "./BrowserAuthError";
+
+export type OSError = {
+    error?: number;
+    protocol_error?: string;
+    properties?: object;
+    status?: string;
+    retryable?: boolean;
+};
+
+const INVALID_METHOD_ERROR = -2147186943;
+
+export const NativeStatusCode = {
+    USER_INTERACTION_REQUIRED: "USER_INTERACTION_REQUIRED",
+    USER_CANCEL: "USER_CANCEL",
+    NO_NETWORK: "NO_NETWORK",
+    TRANSIENT_ERROR: "TRANSIENT_ERROR",
+    PERSISTENT_ERROR: "PERSISTENT_ERROR",
+    DISABLED: "DISABLED",
+    ACCOUNT_UNAVAILABLE: "ACCOUNT_UNAVAILABLE",
+} as const;
+export type NativeStatusCode =
+    (typeof NativeStatusCode)[keyof typeof NativeStatusCode];
+
+export const NativeAuthErrorMessage = {
+    extensionError: {
+        code: "ContentError",
+    },
+    userSwitch: {
+        code: "user_switch",
+        desc: "User attempted to switch accounts in the native broker, which is not allowed. All new accounts must sign-in through the standard web flow first, please try again.",
+    },
+    tokensNotFoundInCache: {
+        code: "tokens_not_found_in_internal_memory_cache",
+        desc: "Tokens not cached in MSAL JS internal memory, please make the WAM request",
+    },
+};
+
+export class NativeAuthError extends AuthError {
+    ext: OSError | undefined;
+
+    constructor(errorCode: string, description: string, ext?: OSError) {
+        super(errorCode, description);
+
+        Object.setPrototypeOf(this, NativeAuthError.prototype);
+        this.name = "NativeAuthError";
+        this.ext = ext;
+    }
+
+    /**
+     * These errors should result in a fallback to the 'standard' browser based auth flow.
+     */
+    isFatal(): boolean {
+        if (
+            this.ext &&
+            this.ext.status &&
+            (this.ext.status === NativeStatusCode.PERSISTENT_ERROR ||
+                this.ext.status === NativeStatusCode.DISABLED)
+        ) {
+            return true;
+        }
+
+        if (
+            this.ext &&
+            this.ext.error &&
+            this.ext.error === INVALID_METHOD_ERROR
+        ) {
+            return true;
+        }
+
+        switch (this.errorCode) {
+            case NativeAuthErrorMessage.extensionError.code:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Create the appropriate error object based on the WAM status code.
+     * @param code
+     * @param description
+     * @param ext
+     * @returns
+     */
+    static createError(
+        code: string,
+        description: string,
+        ext?: OSError
+    ): AuthError {
+        if (ext && ext.status) {
+            switch (ext.status) {
+                case NativeStatusCode.ACCOUNT_UNAVAILABLE:
+                    return InteractionRequiredAuthError.createNativeAccountUnavailableError();
+                case NativeStatusCode.USER_INTERACTION_REQUIRED:
+                    return new InteractionRequiredAuthError(code, description);
+                case NativeStatusCode.USER_CANCEL:
+                    return createBrowserAuthError(
+                        BrowserAuthErrorCodes.userCancelled
+                    );
+                case NativeStatusCode.NO_NETWORK:
+                    return createBrowserAuthError(
+                        BrowserAuthErrorCodes.noNetworkConnectivity
+                    );
+            }
+        }
+
+        return new NativeAuthError(code, description, ext);
+    }
+
+    /**
+     * Creates user switch error when the user chooses a different account in the native broker prompt
+     * @returns
+     */
+    static createUserSwitchError(): NativeAuthError {
+        return new NativeAuthError(
+            NativeAuthErrorMessage.userSwitch.code,
+            NativeAuthErrorMessage.userSwitch.desc
+        );
+    }
+
+    /**
+     * Creates a tokens not found error when the internal cache look up fails
+     * @returns NativeAuthError: tokensNotFoundInCache
+     */
+    static createTokensNotFoundInCacheError(): NativeAuthError {
+        return new NativeAuthError(
+            NativeAuthErrorMessage.tokensNotFoundInCache.code,
+            NativeAuthErrorMessage.tokensNotFoundInCache.desc
+        );
+    }
+}

package/src/event/EventHandler.ts

@@ -0,0 +1,176 @@
+/*
+ * 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";
+
+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 = this.browserCrypto.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,152 @@
+/*
+ * 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,
+    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,
+    AuthErrorMessage,
+    ClientAuthError,
+    ClientAuthErrorMessage,
+    ClientConfigurationError,
+    ClientConfigurationErrorMessage,
+    InteractionRequiredAuthError,
+    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";