@azure/msal-browser/src/interaction_client/BaseInteractionClient.ts

Microsoft Authentication Library for js

/*
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */

import {
    ICrypto,
    INetworkModule,
    Logger,
    AccountInfo,
    UrlString,
    ServerTelemetryManager,
    ServerTelemetryRequest,
    createClientConfigurationError,
    ClientConfigurationErrorCodes,
    Authority,
    AuthorityOptions,
    AuthorityFactory,
    IPerformanceClient,
    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";
import { EndSessionRequest } from "../request/EndSessionRequest.js";
import { RedirectRequest } from "../request/RedirectRequest.js";
import { PopupRequest } from "../request/PopupRequest.js";
import { SsoSilentRequest } from "../request/SsoSilentRequest.js";
import { version } from "../packageMetadata.js";
import { BrowserConstants } from "../utils/BrowserConstants.js";
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 { IPlatformAuthHandler } from "../broker/nativeBroker/IPlatformAuthHandler.js";

export abstract class BaseInteractionClient {
    protected config: BrowserConfiguration;
    protected browserStorage: BrowserCacheManager;
    protected browserCrypto: ICrypto;
    protected networkClient: INetworkModule;
    protected logger: Logger;
    protected eventHandler: EventHandler;
    protected navigationClient: INavigationClient;
    protected platformAuthProvider: IPlatformAuthHandler | undefined;
    protected correlationId: string;
    protected performanceClient: IPerformanceClient;

    constructor(
        config: BrowserConfiguration,
        storageImpl: BrowserCacheManager,
        browserCrypto: ICrypto,
        logger: Logger,
        eventHandler: EventHandler,
        navigationClient: INavigationClient,
        performanceClient: IPerformanceClient,
        correlationId: string,
        platformAuthProvider?: IPlatformAuthHandler
    ) {
        this.config = config;
        this.browserStorage = storageImpl;
        this.browserCrypto = browserCrypto;
        this.networkClient = this.config.system.networkClient;
        this.eventHandler = eventHandler;
        this.navigationClient = navigationClient;
        this.platformAuthProvider = platformAuthProvider;
        this.correlationId = correlationId;
        this.logger = logger.clone(BrowserConstants.MSAL_SKU, version);
        this.performanceClient = performanceClient;
    }

    abstract acquireToken(
        request: RedirectRequest | PopupRequest | SsoSilentRequest
    ): Promise<AuthenticationResult | void>;

    abstract logout(
        request: EndSessionRequest | ClearCacheRequest | undefined
    ): Promise<void>;
}

/**
 * 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());
}

/**
 * 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;

    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
        );
    }

    return discoveredAuthority;
}

/**
 * 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
            );
        }
    }
}