@azure/msal-browser 4.27.0 → 5.0.0-beta.0

package/src/index.ts

@@ -9,6 +9,7 @@
  */
 
 import * as BrowserUtils from "./utils/BrowserUtils.js";
+import { Constants } from "@azure/msal-common/browser";
 export { BrowserUtils };
 
 export {
@@ -16,7 +17,6 @@ export {
     createNestablePublicClientApplication,
     createStandardPublicClientApplication,
 } from "./app/PublicClientApplication.js";
-export { PublicClientNext } from "./app/PublicClientNext.js";
 export { IController } from "./controllers/IController.js";
 export {
     Configuration,
@@ -39,13 +39,11 @@ export {
 // Browser Errors
 export {
     BrowserAuthError,
-    BrowserAuthErrorMessage,
     BrowserAuthErrorCodes,
 } from "./error/BrowserAuthError.js";
 export {
     BrowserConfigurationAuthError,
     BrowserConfigurationAuthErrorCodes,
-    BrowserConfigurationAuthErrorMessage,
 } from "./error/BrowserConfigurationAuthError.js";
 
 // Interfaces
@@ -62,15 +60,15 @@ export { SilentRequest } from "./request/SilentRequest.js";
 export { SsoSilentRequest } from "./request/SsoSilentRequest.js";
 export { EndSessionRequest } from "./request/EndSessionRequest.js";
 export { EndSessionPopupRequest } from "./request/EndSessionPopupRequest.js";
-export { AuthorizationUrlRequest } from "./request/AuthorizationUrlRequest.js";
 export { AuthorizationCodeRequest } from "./request/AuthorizationCodeRequest.js";
 export { AuthenticationResult } from "./response/AuthenticationResult.js";
 export { ClearCacheRequest } from "./request/ClearCacheRequest.js";
 export { InitializeApplicationRequest } from "./request/InitializeApplicationRequest.js";
+export { HandleRedirectPromiseOptions } from "./request/HandleRedirectPromiseOptions.js";
 
 // Cache
 export { LoadTokenOptions } from "./cache/TokenCache.js";
-export { ITokenCache } from "./cache/ITokenCache.js";
+export { loadExternalTokens } from "./cache/TokenCache.js";
 
 // Storage
 export { MemoryStorage } from "./cache/MemoryStorage.js";
@@ -106,26 +104,30 @@ export {
 export { BrowserPerformanceClient } from "./telemetry/BrowserPerformanceClient.js";
 export { BrowserPerformanceMeasurement } from "./telemetry/BrowserPerformanceMeasurement.js";
 
+// Common constants
+export const AuthenticationScheme = Constants.AuthenticationScheme;
+export type AuthenticationScheme = Constants.AuthenticationScheme;
+export const ResponseMode = Constants.ResponseMode;
+export type ResponseMode = Constants.ResponseMode;
+export const PromptValue = Constants.PromptValue;
+export const JsonWebTokenTypes = Constants.JsonWebTokenTypes;
+export type JsonWebTokenTypes = Constants.JsonWebTokenTypes;
+export const OIDC_DEFAULT_SCOPES = Constants.OIDC_DEFAULT_SCOPES;
+
 // 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,
@@ -137,28 +139,21 @@ export {
     LogLevel,
     // Protocol Mode
     ProtocolMode,
-    ServerResponseType,
-    PromptValue,
     // Server Response
     ExternalTokenResponse,
-    // Utils
-    StringUtils,
-    UrlString,
-    JsonWebTokenTypes,
     // AzureCloudInstance enum
     AzureCloudInstance,
     AzureCloudOptions,
     AuthenticationHeaderParser,
-    OIDC_DEFAULT_SCOPES,
     PerformanceCallbackFunction,
     PerformanceEvent,
-    PerformanceEvents,
     // Telemetry
     InProgressPerformanceEvent,
     TenantProfile,
     IPerformanceClient,
     StubPerformanceClient,
 } from "@azure/msal-common/browser";
+export * as BrowserRootPerformanceEvents from "./telemetry/BrowserRootPerformanceEvents.js";
 
 export { version } from "./packageMetadata.js";
 

package/src/interaction_client/BaseInteractionClient.ts

@@ -17,11 +17,11 @@ import {
     AuthorityOptions,
     AuthorityFactory,
     IPerformanceClient,
-    PerformanceEvents,
     AzureCloudOptions,
     invokeAsync,
     StringDict,
 } from "@azure/msal-common/browser";
+import * as BrowserPerformanceEvents from "../telemetry/BrowserPerformanceEvents.js";
 import { BrowserConfiguration } from "../config/Configuration.js";
 import { BrowserCacheManager } from "../cache/BrowserCacheManager.js";
 import { EventHandler } from "../event/EventHandler.js";
@@ -35,7 +35,6 @@ import * as BrowserUtils from "../utils/BrowserUtils.js";
 import { INavigationClient } from "../navigation/INavigationClient.js";
 import { AuthenticationResult } from "../response/AuthenticationResult.js";
 import { ClearCacheRequest } from "../request/ClearCacheRequest.js";
-import { createNewGuid } from "../crypto/BrowserCrypto.js";
 import { IPlatformAuthHandler } from "../broker/nativeBroker/IPlatformAuthHandler.js";
 
 export abstract class BaseInteractionClient {
@@ -58,8 +57,8 @@ export abstract class BaseInteractionClient {
         eventHandler: EventHandler,
         navigationClient: INavigationClient,
         performanceClient: IPerformanceClient,
-        platformAuthProvider?: IPlatformAuthHandler,
-        correlationId?: string
+        correlationId: string,
+        platformAuthProvider?: IPlatformAuthHandler
     ) {
         this.config = config;
         this.browserStorage = storageImpl;
@@ -68,12 +67,8 @@ export abstract class BaseInteractionClient {
         this.eventHandler = eventHandler;
         this.navigationClient = navigationClient;
         this.platformAuthProvider = platformAuthProvider;
-        this.correlationId = correlationId || createNewGuid();
-        this.logger = logger.clone(
-            BrowserConstants.MSAL_SKU,
-            version,
-            this.correlationId
-        );
+        this.correlationId = correlationId;
+        this.logger = logger.clone(BrowserConstants.MSAL_SKU, version);
         this.performanceClient = performanceClient;
     }
 
@@ -84,162 +79,190 @@ export abstract class BaseInteractionClient {
     abstract logout(
         request: EndSessionRequest | ClearCacheRequest | undefined
     ): Promise<void>;
+}
 
-    protected async clearCacheOnLogout(
-        correlationId: string,
-        account?: AccountInfo | null
-    ): Promise<void> {
-        if (account) {
-            // Clear given account.
-            try {
-                this.browserStorage.removeAccount(account, correlationId);
-                this.logger.verbose(
-                    "Cleared cache items belonging to the account provided in the logout request."
-                );
-            } catch (error) {
-                this.logger.error(
-                    "Account provided in logout request was not found. Local cache unchanged."
-                );
-            }
-        } else {
-            try {
-                this.logger.verbose(
-                    "No account provided in logout request, clearing all cache items.",
-                    this.correlationId
-                );
-                // Clear all accounts and tokens
-                this.browserStorage.clear(correlationId);
-                // Clear any stray keys from IndexedDB
-                await this.browserCrypto.clearKeystore();
-            } catch (e) {
-                this.logger.error(
-                    "Attempted to clear all MSAL cache items and failed. Local cache unchanged."
-                );
-            }
-        }
-    }
+/**
+ * Use to get the redirect URI configured in MSAL or construct one from the current page.
+ * @param requestRedirectUri - Redirect URI from the request or undefined if not configured
+ * @param clientConfigRedirectUri - Redirect URI from the client configuration or undefined if not configured
+ * @param logger - Logger instance from the calling client
+ * @param correlationId
+ * @returns Absolute redirect URL constructed from the provided URI, config, or current page
+ */
+export function getRedirectUri(
+    requestRedirectUri: string | undefined,
+    clientConfigRedirectUri: string | undefined,
+    logger: Logger,
+    correlationId: string
+): string {
+    logger.verbose("getRedirectUri called", correlationId);
+    const redirectUri = requestRedirectUri || clientConfigRedirectUri || "";
+    return UrlString.getAbsoluteUrl(redirectUri, BrowserUtils.getCurrentUri());
+}
 
-    /**
-     *
-     * Use to get the redirect uri configured in MSAL or null.
-     * @param requestRedirectUri
-     * @returns Redirect URL
-     *
-     */
-    getRedirectUri(requestRedirectUri?: string): string {
-        this.logger.verbose("getRedirectUri called");
-        const redirectUri = requestRedirectUri || this.config.auth.redirectUri;
-        return UrlString.getAbsoluteUrl(
-            redirectUri,
-            BrowserUtils.getCurrentUri()
-        );
-    }
+/**
+ * Initializes and returns a ServerTelemetryManager with the provided telemetry configuration.
+ * @param apiId - The API identifier for telemetry tracking
+ * @param clientId - The client application identifier
+ * @param correlationId - Unique identifier for correlating requests
+ * @param browserStorage - Browser cache manager instance for storing telemetry data
+ * @param logger - Optional logger instance for verbose logging
+ * @param forceRefresh - Optional flag to force refresh of telemetry data
+ * @returns Configured ServerTelemetryManager instance
+ */
+export function initializeServerTelemetryManager(
+    apiId: number,
+    clientId: string,
+    correlationId: string,
+    browserStorage: BrowserCacheManager,
+    logger: Logger,
+    forceRefresh?: boolean
+): ServerTelemetryManager {
+    logger.verbose("initializeServerTelemetryManager called", correlationId);
+    const telemetryPayload: ServerTelemetryRequest = {
+        clientId: clientId,
+        correlationId: correlationId,
+        apiId: apiId,
+        forceRefresh: forceRefresh || false,
+        wrapperSKU: browserStorage.getWrapperMetadata()[0],
+        wrapperVer: browserStorage.getWrapperMetadata()[1],
+    };
+
+    return new ServerTelemetryManager(telemetryPayload, browserStorage);
+}
+
+/**
+ * Used to get a discovered version of the default authority.
+ * @param params - Configuration object containing authority and cloud options
+ * @param params.requestAuthority - Optional specific authority URL to use
+ * @param params.requestAzureCloudOptions - Optional Azure cloud configuration options
+ * @param params.requestExtraQueryParameters - Optional additional query parameters
+ * @param params.account - Optional account info for instance-aware scenarios
+ * @param config - Browser configuration containing auth settings
+ * @param correlationId - Unique identifier for correlating requests
+ * @param performanceClient - Performance monitoring client instance
+ * @param browserStorage - Browser cache manager instance
+ * @param logger - Logger instance for tracking operations
+ * @returns Promise that resolves to a discovered Authority instance
+ */
+export async function getDiscoveredAuthority(
+    config: BrowserConfiguration,
+    correlationId: string,
+    performanceClient: IPerformanceClient,
+    browserStorage: BrowserCacheManager,
+    logger: Logger,
+    requestAuthority?: string,
+    requestAzureCloudOptions?: AzureCloudOptions,
+    requestExtraQueryParameters?: StringDict,
+    account?: AccountInfo
+): Promise<Authority> {
+    const instanceAwareEQ =
+        requestExtraQueryParameters &&
+        requestExtraQueryParameters.hasOwnProperty("instance_aware")
+            ? requestExtraQueryParameters["instance_aware"]
+            : undefined;
 
-    /**
-     *
-     * @param apiId
-     * @param correlationId
-     * @param forceRefresh
-     */
-    protected initializeServerTelemetryManager(
-        apiId: number,
-        forceRefresh?: boolean
-    ): ServerTelemetryManager {
-        this.logger.verbose("initializeServerTelemetryManager called");
-        const telemetryPayload: ServerTelemetryRequest = {
-            clientId: this.config.auth.clientId,
-            correlationId: this.correlationId,
-            apiId: apiId,
-            forceRefresh: forceRefresh || false,
-            wrapperSKU: this.browserStorage.getWrapperMetadata()[0],
-            wrapperVer: this.browserStorage.getWrapperMetadata()[1],
-        };
-
-        return new ServerTelemetryManager(
-            telemetryPayload,
-            this.browserStorage
+    const authorityOptions: AuthorityOptions = {
+        protocolMode: config.system.protocolMode,
+        OIDCOptions: config.auth.OIDCOptions,
+        knownAuthorities: config.auth.knownAuthorities,
+        cloudDiscoveryMetadata: config.auth.cloudDiscoveryMetadata,
+        authorityMetadata: config.auth.authorityMetadata,
+    };
+
+    // build authority string based on auth params, precedence - azureCloudInstance + tenant >> authority
+    const resolvedAuthority = requestAuthority || config.auth.authority;
+    const resolvedInstanceAware = instanceAwareEQ?.length
+        ? instanceAwareEQ === "true"
+        : config.auth.instanceAware;
+
+    const userAuthority =
+        account && resolvedInstanceAware
+            ? config.auth.authority.replace(
+                  UrlString.getDomainFromUrl(resolvedAuthority),
+                  account.environment
+              )
+            : resolvedAuthority;
+
+    // fall back to the authority from config
+    const builtAuthority = Authority.generateAuthority(
+        userAuthority,
+        requestAzureCloudOptions || config.auth.azureCloudOptions
+    );
+    const discoveredAuthority = await invokeAsync(
+        AuthorityFactory.createDiscoveredInstance,
+        BrowserPerformanceEvents.AuthorityFactoryCreateDiscoveredInstance,
+        logger,
+        performanceClient,
+        correlationId
+    )(
+        builtAuthority,
+        config.system.networkClient,
+        browserStorage,
+        authorityOptions,
+        logger,
+        correlationId,
+        performanceClient
+    );
+
+    if (account && !discoveredAuthority.isAlias(account.environment)) {
+        throw createClientConfigurationError(
+            ClientConfigurationErrorCodes.authorityMismatch
         );
     }
 
-    /**
-     * Used to get a discovered version of the default authority.
-     * @param params {
-     *         requestAuthority?: string;
-     *         requestAzureCloudOptions?: AzureCloudOptions;
-     *         requestExtraQueryParameters?: StringDict;
-     *         account?: AccountInfo;
-     *        }
-     */
-    protected async getDiscoveredAuthority(params: {
-        requestAuthority?: string;
-        requestAzureCloudOptions?: AzureCloudOptions;
-        requestExtraQueryParameters?: StringDict;
-        account?: AccountInfo;
-    }): Promise<Authority> {
-        const { account } = params;
-        const instanceAwareEQ =
-            params.requestExtraQueryParameters &&
-            params.requestExtraQueryParameters.hasOwnProperty("instance_aware")
-                ? params.requestExtraQueryParameters["instance_aware"]
-                : undefined;
-
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
-            this.correlationId
-        );
-        const authorityOptions: AuthorityOptions = {
-            protocolMode: this.config.auth.protocolMode,
-            OIDCOptions: this.config.auth.OIDCOptions,
-            knownAuthorities: this.config.auth.knownAuthorities,
-            cloudDiscoveryMetadata: this.config.auth.cloudDiscoveryMetadata,
-            authorityMetadata: this.config.auth.authorityMetadata,
-            skipAuthorityMetadataCache:
-                this.config.auth.skipAuthorityMetadataCache,
-        };
-
-        // build authority string based on auth params, precedence - azureCloudInstance + tenant >> authority
-        const resolvedAuthority =
-            params.requestAuthority || this.config.auth.authority;
-        const resolvedInstanceAware = instanceAwareEQ?.length
-            ? instanceAwareEQ === "true"
-            : this.config.auth.instanceAware;
-
-        const userAuthority =
-            account && resolvedInstanceAware
-                ? this.config.auth.authority.replace(
-                      UrlString.getDomainFromUrl(resolvedAuthority),
-                      account.environment
-                  )
-                : resolvedAuthority;
-
-        // fall back to the authority from config
-        const builtAuthority = Authority.generateAuthority(
-            userAuthority,
-            params.requestAzureCloudOptions ||
-                this.config.auth.azureCloudOptions
-        );
-        const discoveredAuthority = await invokeAsync(
-            AuthorityFactory.createDiscoveredInstance,
-            PerformanceEvents.AuthorityFactoryCreateDiscoveredInstance,
-            this.logger,
-            this.performanceClient,
-            this.correlationId
-        )(
-            builtAuthority,
-            this.config.system.networkClient,
-            this.browserStorage,
-            authorityOptions,
-            this.logger,
-            this.correlationId,
-            this.performanceClient
-        );
+    return discoveredAuthority;
+}
 
-        if (account && !discoveredAuthority.isAlias(account.environment)) {
-            throw createClientConfigurationError(
-                ClientConfigurationErrorCodes.authorityMismatch
+/**
+ * Clears cache and account information during logout.
+ *
+ * If an account is provided, removes the account from cache and, if it is the active account, sets the active account to null.
+ * If no account is provided, clears all accounts and tokens from cache.
+ *
+ * @param browserStorage - The browser cache manager instance used to manage cache.
+ * @param browserCrypto - The crypto interface for cache operations.
+ * @param logger - Logger instance for logging operations.
+ * @param correlationId - Correlation ID for the logout operation.
+ * @param account - (Optional) The account to clear from cache. If not provided, all accounts are cleared.
+ * @returns A promise that resolves when the cache has been cleared.
+ */
+export async function clearCacheOnLogout(
+    browserStorage: BrowserCacheManager,
+    browserCrypto: ICrypto,
+    logger: Logger,
+    correlationId: string,
+    account?: AccountInfo | null
+): Promise<void> {
+    if (account) {
+        // Clear given account.
+        try {
+            browserStorage.removeAccount(account, correlationId);
+            logger.verbose(
+                "Cleared cache items belonging to the account provided in the logout request.",
+                correlationId
+            );
+        } catch (error) {
+            logger.error(
+                "Account provided in logout request was not found. Local cache unchanged.",
+                correlationId
+            );
+        }
+    } else {
+        try {
+            logger.verbose(
+                "No account provided in logout request, clearing all cache items.",
+                correlationId
+            );
+            // Clear all accounts and tokens
+            browserStorage.clear(correlationId);
+            // Clear any stray keys from IndexedDB
+            await browserCrypto.clearKeystore(correlationId);
+        } catch (e) {
+            logger.error(
+                "Attempted to clear all MSAL cache items and failed. Local cache unchanged.",
+                correlationId
             );
         }
-
-        return discoveredAuthority;
     }
 }

package/src/interaction_client/HybridSpaAuthorizationCodeClient.ts

@@ -6,11 +6,15 @@
 import {
     AuthorizationCodeClient,
     ClientConfiguration,
+    IPerformanceClient,
 } from "@azure/msal-common/browser";
 
 export class HybridSpaAuthorizationCodeClient extends AuthorizationCodeClient {
-    constructor(config: ClientConfiguration) {
-        super(config);
+    constructor(
+        config: ClientConfiguration,
+        performanceClient: IPerformanceClient
+    ) {
+        super(config, performanceClient);
         this.includeRedirectUri = false;
     }
 }