@azure/msal-browser 3.1.0 → 3.3.0

package/src/naa/mapping/NestedAppAuthAdapter.ts

@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { TokenRequest } from "../TokenRequest";
+import { AccountInfo as NaaAccountInfo } from "../AccountInfo";
+import { RedirectRequest } from "../../request/RedirectRequest";
+import { PopupRequest } from "../../request/PopupRequest";
+import { TokenResponse } from "../TokenResponse";
+import {
+    AccountInfo as MsalAccountInfo,
+    AuthError,
+    ClientAuthError,
+    ClientConfigurationError,
+    InteractionRequiredAuthError,
+    ServerError,
+    TimeUtils,
+    ICrypto,
+    Logger,
+    AuthToken,
+    TokenClaims,
+    ClientAuthErrorCodes,
+} from "@azure/msal-common";
+import { isBridgeError } from "../BridgeError";
+import { BridgeStatusCode } from "../BridgeStatusCode";
+import { SilentRequest } from "../../request/SilentRequest";
+import { AuthenticationResult } from "../../response/AuthenticationResult";
+import {} from "../../error/BrowserAuthErrorCodes";
+
+export class NestedAppAuthAdapter {
+    protected crypto: ICrypto;
+    protected logger: Logger;
+    protected clientId: string;
+    protected clientCapabilities: string[];
+
+    constructor(
+        clientId: string,
+        clientCapabilities: string[],
+        crypto: ICrypto,
+        logger: Logger
+    ) {
+        this.clientId = clientId;
+        this.clientCapabilities = clientCapabilities;
+        this.crypto = crypto;
+        this.logger = logger;
+    }
+
+    public toNaaSilentTokenRequest(request: SilentRequest): TokenRequest {
+        let extraParams: Map<string, string>;
+        if (request.extraQueryParameters === undefined) {
+            extraParams = new Map<string, string>();
+        } else {
+            extraParams = new Map<string, string>(
+                Object.entries(request.extraQueryParameters)
+            );
+        }
+        /**
+         * Need to get information about the client to populate request correctly
+         * For example: client id, client capabilities
+         */
+        const tokenRequest: TokenRequest = {
+            userObjectId: request.account?.homeAccountId,
+            clientId: this.clientId,
+            authority: request.authority,
+            scope: request.scopes.join(" "),
+            correlationId:
+                request.correlationId !== undefined
+                    ? request.correlationId
+                    : this.crypto.createNewGuid(),
+            prompt: request.prompt !== undefined ? request.prompt : "",
+            claims: request.claims !== undefined ? request.claims : "",
+            authenticationScheme:
+                request.authenticationScheme !== undefined
+                    ? request.authenticationScheme
+                    : "",
+            clientCapabilities: this.clientCapabilities,
+            extraParameters: extraParams,
+        };
+
+        return tokenRequest;
+    }
+
+    public toNaaTokenRequest(
+        request: PopupRequest | RedirectRequest
+    ): TokenRequest {
+        let extraParams: Map<string, string>;
+        if (request.extraQueryParameters === undefined) {
+            extraParams = new Map<string, string>();
+        } else {
+            extraParams = new Map<string, string>(
+                Object.entries(request.extraQueryParameters)
+            );
+        }
+
+        const tokenRequest: TokenRequest = {
+            userObjectId: request.account?.homeAccountId,
+            clientId: this.clientId,
+            authority: request.authority,
+            scope: request.scopes.join(" "),
+            correlationId:
+                request.correlationId !== undefined
+                    ? request.correlationId
+                    : "",
+            prompt: request.prompt !== undefined ? request.prompt : "",
+            nonce: request.nonce !== undefined ? request.nonce : "",
+            claims: request.claims !== undefined ? request.claims : "",
+            state: request.state !== undefined ? request.state : "",
+            authenticationScheme:
+                request.authenticationScheme !== undefined
+                    ? request.authenticationScheme
+                    : "",
+            clientCapabilities: undefined,
+            extraParameters: extraParams,
+        };
+
+        return tokenRequest;
+    }
+
+    public fromNaaTokenResponse(
+        request: TokenRequest,
+        response: TokenResponse
+    ): AuthenticationResult {
+        const expiresOn = new Date(
+            TimeUtils.nowSeconds() + (response.expires_in || 0) * 1000
+        );
+
+        const account = this.fromNaaAccountInfo(response.account);
+
+        const authenticationResult: AuthenticationResult = {
+            authority: response.account.environment,
+            uniqueId: response.account.homeAccountId,
+            tenantId: response.account.tenantId,
+            scopes: response.scope.split(" "),
+            account: this.fromNaaAccountInfo(response.account),
+            idToken: response.id_token !== undefined ? response.id_token : "",
+            idTokenClaims:
+                account.idTokenClaims !== undefined
+                    ? account.idTokenClaims
+                    : {},
+            accessToken: response.access_token,
+            fromCache: true,
+            expiresOn: expiresOn,
+            tokenType:
+                request.authenticationScheme !== undefined
+                    ? request.authenticationScheme
+                    : "Bearer",
+            correlationId: request.correlationId,
+            requestId: "",
+            extExpiresOn: expiresOn,
+            state: response.state,
+        };
+
+        return authenticationResult;
+    }
+
+    /*
+     *  export type AccountInfo = {
+     *     homeAccountId: string;
+     *     environment: string;
+     *     tenantId: string;
+     *     username: string;
+     *     localAccountId: string;
+     *     name?: string;
+     *     idToken?: string;
+     *     idTokenClaims?: TokenClaims & {
+     *         [key: string]:
+     *             | string
+     *             | number
+     *             | string[]
+     *             | object
+     *             | undefined
+     *             | unknown;
+     *     };
+     *     nativeAccountId?: string;
+     *     authorityType?: string;
+     * };
+     */
+    public fromNaaAccountInfo(fromAccount: NaaAccountInfo): MsalAccountInfo {
+        let tokenClaims: TokenClaims | undefined;
+        if (fromAccount.idToken !== undefined) {
+            tokenClaims = AuthToken.extractTokenClaims(
+                fromAccount.idToken,
+                this.crypto.base64Decode
+            );
+        } else {
+            tokenClaims = undefined;
+        }
+
+        const account: MsalAccountInfo = {
+            homeAccountId: fromAccount.homeAccountId,
+            environment: fromAccount.environment,
+            tenantId: fromAccount.tenantId,
+            username: fromAccount.username,
+            localAccountId: fromAccount.localAccountId,
+            name: fromAccount.name,
+            idToken: fromAccount.idToken,
+            idTokenClaims: tokenClaims,
+        };
+
+        return account;
+    }
+
+    /**
+     *
+     * @param error BridgeError
+     * @returns AuthError, ClientAuthError, ClientConfigurationError, ServerError, InteractionRequiredError
+     */
+    public fromBridgeError(
+        error: unknown
+    ):
+        | AuthError
+        | ClientAuthError
+        | ClientConfigurationError
+        | ServerError
+        | InteractionRequiredAuthError {
+        if (isBridgeError(error)) {
+            switch (error.status) {
+                case BridgeStatusCode.USER_CANCEL:
+                    return new ClientAuthError(
+                        ClientAuthErrorCodes.userCanceled
+                    );
+                case BridgeStatusCode.NO_NETWORK:
+                    return new ClientAuthError(
+                        ClientAuthErrorCodes.noNetworkConnectivity
+                    );
+                case BridgeStatusCode.ACCOUNT_UNAVAILABLE:
+                    return new ClientAuthError(
+                        ClientAuthErrorCodes.noAccountFound
+                    );
+                case BridgeStatusCode.DISABLED:
+                    return new ClientAuthError(
+                        ClientAuthErrorCodes.nestedAppAuthBridgeDisabled
+                    );
+                case BridgeStatusCode.NESTED_APP_AUTH_UNAVAILABLE:
+                    return new ClientAuthError(error.code, error.description);
+                case BridgeStatusCode.TRANSIENT_ERROR:
+                case BridgeStatusCode.PERSISTENT_ERROR:
+                    return new ServerError(error.code, error.description);
+                case BridgeStatusCode.USER_INTERACTION_REQUIRED:
+                    return new InteractionRequiredAuthError(
+                        error.code,
+                        error.description
+                    );
+                default:
+                    return new AuthError(error.code, error.description);
+            }
+        } else {
+            return new AuthError("unknown_error", "An unknown error occurred");
+        }
+    }
+}

package/src/operatingcontext/TeamsAppOperatingContext.ts

@@ -4,8 +4,14 @@
  */
 
 import { BaseOperatingContext } from "./BaseOperatingContext";
+import { IBridgeProxy } from "../naa/IBridgeProxy";
+import { BridgeProxy } from "../naa/BridgeProxy";
+import { AccountInfo } from "../naa/AccountInfo";
 
 export class TeamsAppOperatingContext extends BaseOperatingContext {
+    protected bridgeProxy: IBridgeProxy | undefined = undefined;
+    protected activeAccount: AccountInfo | undefined = undefined;
+
     /*
      * TODO: Once we have determine the bundling code return here to specify the name of the bundle
      * containing the implementation for this operating context
@@ -33,6 +39,18 @@ export class TeamsAppOperatingContext extends BaseOperatingContext {
         return TeamsAppOperatingContext.ID;
     }
 
+    getBridgeProxy(): IBridgeProxy | undefined {
+        return this.bridgeProxy;
+    }
+
+    getActiveAccount(): AccountInfo | undefined {
+        return this.activeAccount;
+    }
+
+    setActiveAccount(account: AccountInfo): void {
+        this.activeAccount = account;
+    }
+
     /**
      * Checks whether the operating context is available.
      * Confirms that the code is running a browser rather.  This is required.
@@ -40,9 +58,31 @@ export class TeamsAppOperatingContext extends BaseOperatingContext {
      */
     async initialize(): Promise<boolean> {
         /*
-         * TODO: Add implementation to check for presence of inject MetaOSHub JavaScript interface
-         * TODO: Make pre-flight token request to ensure that App is eligible to use Nested App Auth
+         * TODO: Add implementation to check for presence of inject Nested App Auth Bridge JavaScript interface
+         *
          */
-        return false;
+        try {
+            if (typeof window !== "undefined") {
+                const bridgeProxy: IBridgeProxy = await BridgeProxy.create();
+                /*
+                 * Because we want single sign on we need to attempt to
+                 * grab the active account as part of initialization
+                 * this.activeAccount = await bridgeProxy.getActiveAccount();
+                 */
+                try {
+                    this.activeAccount = await bridgeProxy.getActiveAccount();
+                } catch (e) {
+                    this.activeAccount = undefined;
+                }
+                this.bridgeProxy = bridgeProxy;
+                this.available = bridgeProxy !== undefined;
+            } else {
+                this.available = false;
+            }
+        } catch (e) {
+            this.available = false;
+        } finally {
+            return this.available;
+        }
     }
 }

package/src/operatingcontext/UnknownOperatingContext.ts

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { BaseOperatingContext } from "./BaseOperatingContext";
+
+export class UnknownOperatingContext extends BaseOperatingContext {
+    /*
+     * TODO: Once we have determine the bundling code return here to specify the name of the bundle
+     * containing the implementation for this operating context
+     */
+    static readonly MODULE_NAME: string = "";
+
+    /**
+     * Unique identifier for the operating context
+     */
+    static readonly ID: string = "UnknownOperatingContext";
+
+    /**
+     * Return the module name.  Intended for use with import() to enable dynamic import
+     * of the implementation associated with this operating context
+     * @returns
+     */
+    getModuleName(): string {
+        return UnknownOperatingContext.MODULE_NAME;
+    }
+    /**
+     * Returns the unique identifier for this operating context
+     * @returns string
+     */
+    getId(): string {
+        return UnknownOperatingContext.ID;
+    }
+
+    /**
+     * Checks whether the operating context is available.
+     * Confirms that the code is running a browser rather.  This is required.
+     * @returns Promise<boolean> indicating whether this operating context is currently available.
+     */
+    async initialize(): Promise<boolean> {
+        /**
+         * This operating context is in use when we have not checked for what the operating context is.
+         * The context is unknown until we check it.
+         */
+        return true;
+    }
+}

package/src/packageMetadata.ts

@@ -1,3 +1,3 @@
 /* eslint-disable header/header */
 export const name = "@azure/msal-browser";
-export const version = "3.1.0";
+export const version = "3.3.0";

package/src/utils/BrowserProtocolUtils.ts

@@ -5,12 +5,13 @@
 
 import { InteractionType } from "./BrowserConstants";
 import {
-    ClientAuthError,
     ICrypto,
     RequestStateObject,
     ProtocolUtils,
     ServerAuthorizationCodeResponse,
     UrlString,
+    createClientAuthError,
+    ClientAuthErrorCodes,
 } from "@azure/msal-common";
 
 export type BrowserStateObject = {
@@ -36,7 +37,7 @@ export class BrowserProtocolUtils {
                 ProtocolUtils.parseRequestState(browserCrypto, state);
             return requestStateObj.libraryState.meta as BrowserStateObject;
         } catch (e) {
-            throw ClientAuthError.createInvalidStateError(state, e as string);
+            throw createClientAuthError(ClientAuthErrorCodes.invalidState);
         }
     }