@azure/msal-browser 3.14.0 → 3.16.0

package/package.json

@@ -10,7 +10,7 @@
     "type": "git",
     "url": "https://github.com/AzureAD/microsoft-authentication-library-for-js.git"
   },
-  "version": "3.14.0",
+  "version": "3.16.0",
   "description": "Microsoft Authentication Library for js",
   "keywords": [
     "implicit",
@@ -69,7 +69,8 @@
     "build": "npm run clean && npm run build:modules",
     "prepack": "npm run build:all",
     "format:check": "prettier --ignore-path .gitignore --check src test",
-    "format:fix": "prettier --ignore-path .gitignore --write src test"
+    "format:fix": "prettier --ignore-path .gitignore --write src test",
+    "apiExtractor": "api-extractor run"
   },
   "devDependencies": {
     "@azure/storage-blob": "^12.2.1",
@@ -78,6 +79,7 @@
     "@babel/plugin-proposal-object-rest-spread": "^7.6.2",
     "@babel/preset-env": "^7.7.1",
     "@babel/preset-typescript": "^7.7.2",
+    "@microsoft/api-extractor": "^7.43.4",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-terser": "^0.4.0",
     "@rollup/plugin-typescript": "^11.0.0",
@@ -90,7 +92,7 @@
     "jest": "^29.5.0",
     "jest-environment-jsdom": "^29.5.0",
     "msal-test-utils": "file:../../shared-test-utils",
-    "prettier": "2.8.7",
+    "prettier": "^2.8.7",
     "rimraf": "^3.0.0",
     "rollup": "^3.14.0",
     "shx": "^0.3.2",
@@ -101,6 +103,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "@azure/msal-common": "14.10.0"
+    "@azure/msal-common": "14.11.0"
   }
 }

package/src/app/PublicClientApplication.ts

@@ -28,6 +28,8 @@ import { AuthenticationResult } from "../response/AuthenticationResult";
 import { EventCallbackFunction } from "../event/EventMessage";
 import { ClearCacheRequest } from "../request/ClearCacheRequest";
 import { EndSessionPopupRequest } from "../request/EndSessionPopupRequest";
+import { NestedAppAuthController } from "../controllers/NestedAppAuthController";
+import { NestedAppOperatingContext } from "../operatingcontext/NestedAppOperatingContext";
 
 /**
  * The PublicClientApplication class is the object exposed by the library to perform authentication and authorization functions in Single Page Applications
@@ -36,6 +38,7 @@ import { EndSessionPopupRequest } from "../request/EndSessionPopupRequest";
 export class PublicClientApplication implements IPublicClientApplication {
     protected controller: IController;
 
+    // creates StandardController and passes it to the PublicClientApplication
     public static async createPublicClientApplication(
         configuration: Configuration
     ): Promise<IPublicClientApplication> {
@@ -70,14 +73,9 @@ export class PublicClientApplication implements IPublicClientApplication {
      * @param IController Optional parameter to explictly set the controller. (Will be removed when we remove public constructor)
      */
     public constructor(configuration: Configuration, controller?: IController) {
-        if (controller) {
-            this.controller = controller;
-        } else {
-            const standardOperatingContext = new StandardOperatingContext(
-                configuration
-            );
-            this.controller = new StandardController(standardOperatingContext);
-        }
+        this.controller =
+            controller ||
+            new StandardController(new StandardOperatingContext(configuration));
     }
 
     /**
@@ -417,3 +415,40 @@ export class PublicClientApplication implements IPublicClientApplication {
         return this.controller.clearCache(logoutRequest);
     }
 }
+
+/**
+ * creates NestedAppAuthController and passes it to the PublicClientApplication,
+ * falls back to StandardController if NestedAppAuthController is not available
+ *
+ * @param configuration
+ * @returns IPublicClientApplication
+ *
+ */
+export async function createNestablePublicClientApplication(
+    configuration: Configuration
+): Promise<IPublicClientApplication> {
+    const nestedAppAuth = new NestedAppOperatingContext(configuration);
+    await nestedAppAuth.initialize();
+
+    if (nestedAppAuth.isAvailable()) {
+        const controller = new NestedAppAuthController(nestedAppAuth);
+        return new PublicClientApplication(configuration, controller);
+    }
+
+    return createStandardPublicClientApplication(configuration);
+}
+
+/**
+ * creates PublicClientApplication using StandardController
+ *
+ * @param configuration
+ * @returns IPublicClientApplication
+ *
+ */
+export async function createStandardPublicClientApplication(
+    configuration: Configuration
+): Promise<IPublicClientApplication> {
+    const pca = new PublicClientApplication(configuration);
+    await pca.initialize();
+    return pca;
+}

package/src/app/PublicClientNext.ts

@@ -35,6 +35,9 @@ import { UnknownOperatingContext } from "../operatingcontext/UnknownOperatingCon
  * The goals of these changes are to provide a clean separation of behavior between different operating contexts (Nested App Auth, Platform Brokers, Plain old Browser, etc.)
  * while still providing a consistent API surface for developers.
  *
+ * Please use PublicClientApplication for any prod/real-world scenarios.
+ * Note: PublicClientNext is experimental and subject to breaking changes without following semver
+ *
  */
 export class PublicClientNext implements IPublicClientApplication {
     /*

package/src/cache/AccountManager.ts

@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AccountInfo, AccountFilter, Logger } from "@azure/msal-common";
+import { BrowserCacheManager } from "./BrowserCacheManager";
+
+/**
+ * Returns all the accounts in the cache that match the optional filter. If no filter is provided, all accounts are returned.
+ * @param accountFilter - (Optional) filter to narrow down the accounts returned
+ * @returns Array of AccountInfo objects in cache
+ */
+export function getAllAccounts(
+    logger: Logger,
+    browserStorage: BrowserCacheManager,
+    isInBrowser: boolean,
+    accountFilter?: AccountFilter
+): AccountInfo[] {
+    logger.verbose("getAllAccounts called");
+    return isInBrowser ? browserStorage.getAllAccounts(accountFilter) : [];
+}
+
+/**
+ * Returns the first account found in the cache that matches the account filter passed in.
+ * @param accountFilter
+ * @returns The first account found in the cache matching the provided filter or null if no account could be found.
+ */
+export function getAccount(
+    accountFilter: AccountFilter,
+    logger: Logger,
+    browserStorage: BrowserCacheManager
+): AccountInfo | null {
+    logger.trace("getAccount called");
+    if (Object.keys(accountFilter).length === 0) {
+        logger.warning("getAccount: No accountFilter provided");
+        return null;
+    }
+
+    const account: AccountInfo | null =
+        browserStorage.getAccountInfoFilteredBy(accountFilter);
+
+    if (account) {
+        logger.verbose(
+            "getAccount: Account matching provided filter found, returning"
+        );
+        return account;
+    } else {
+        logger.verbose("getAccount: No matching account found, returning null");
+        return null;
+    }
+}
+
+/**
+ * Returns the signed in account matching username.
+ * (the account object is created at the time of successful login)
+ * or null when no matching account is found.
+ * This API is provided for convenience but getAccountById should be used for best reliability
+ * @param username
+ * @returns The account object stored in MSAL
+ */
+export function getAccountByUsername(
+    username: string,
+    logger: Logger,
+    browserStorage: BrowserCacheManager
+): AccountInfo | null {
+    logger.trace("getAccountByUsername called");
+    if (!username) {
+        logger.warning("getAccountByUsername: No username provided");
+        return null;
+    }
+
+    const account = browserStorage.getAccountInfoFilteredBy({
+        username,
+    });
+    if (account) {
+        logger.verbose(
+            "getAccountByUsername: Account matching username found, returning"
+        );
+        logger.verbosePii(
+            `getAccountByUsername: Returning signed-in accounts matching username: ${username}`
+        );
+        return account;
+    } else {
+        logger.verbose(
+            "getAccountByUsername: No matching account found, returning null"
+        );
+        return null;
+    }
+}
+
+/**
+ * Returns the signed in account matching homeAccountId.
+ * (the account object is created at the time of successful login)
+ * or null when no matching account is found
+ * @param homeAccountId
+ * @returns The account object stored in MSAL
+ */
+export function getAccountByHomeId(
+    homeAccountId: string,
+    logger: Logger,
+    browserStorage: BrowserCacheManager
+): AccountInfo | null {
+    logger.trace("getAccountByHomeId called");
+    if (!homeAccountId) {
+        logger.warning("getAccountByHomeId: No homeAccountId provided");
+        return null;
+    }
+
+    const account = browserStorage.getAccountInfoFilteredBy({
+        homeAccountId,
+    });
+    if (account) {
+        logger.verbose(
+            "getAccountByHomeId: Account matching homeAccountId found, returning"
+        );
+        logger.verbosePii(
+            `getAccountByHomeId: Returning signed-in accounts matching homeAccountId: ${homeAccountId}`
+        );
+        return account;
+    } else {
+        logger.verbose(
+            "getAccountByHomeId: No matching account found, returning null"
+        );
+        return null;
+    }
+}
+
+/**
+ * Returns the signed in account matching localAccountId.
+ * (the account object is created at the time of successful login)
+ * or null when no matching account is found
+ * @param localAccountId
+ * @returns The account object stored in MSAL
+ */
+export function getAccountByLocalId(
+    localAccountId: string,
+    logger: Logger,
+    browserStorage: BrowserCacheManager
+): AccountInfo | null {
+    logger.trace("getAccountByLocalId called");
+    if (!localAccountId) {
+        logger.warning("getAccountByLocalId: No localAccountId provided");
+        return null;
+    }
+
+    const account = browserStorage.getAccountInfoFilteredBy({
+        localAccountId,
+    });
+    if (account) {
+        logger.verbose(
+            "getAccountByLocalId: Account matching localAccountId found, returning"
+        );
+        logger.verbosePii(
+            `getAccountByLocalId: Returning signed-in accounts matching localAccountId: ${localAccountId}`
+        );
+        return account;
+    } else {
+        logger.verbose(
+            "getAccountByLocalId: No matching account found, returning null"
+        );
+        return null;
+    }
+}
+
+/**
+ * Sets the account to use as the active account. If no account is passed to the acquireToken APIs, then MSAL will use this active account.
+ * @param account
+ */
+export function setActiveAccount(
+    account: AccountInfo | null,
+    browserStorage: BrowserCacheManager
+): void {
+    browserStorage.setActiveAccount(account);
+}
+
+/**
+ * Gets the currently active account
+ */
+export function getActiveAccount(
+    browserStorage: BrowserCacheManager
+): AccountInfo | null {
+    return browserStorage.getActiveAccount();
+}

package/src/cache/BrowserCacheManager.ts

@@ -1837,6 +1837,15 @@ export class BrowserCacheManager extends CacheManager {
         if (request.claims) {
             claimsHash = await this.cryptoImpl.hashString(request.claims);
         }
+
+        /**
+         * meta data for cache stores time in seconds from epoch
+         * AuthenticationResult returns expiresOn and extExpiresOn in milliseconds (as a Date object which is in ms)
+         * We need to map these for the cache when building tokens from AuthenticationResult
+         *
+         * The next MSAL VFuture should map these both to same value if possible
+         */
+
         const accessTokenEntity = CacheHelpers.createAccessTokenEntity(
             result.account?.homeAccountId,
             result.account.environment,
@@ -1844,8 +1853,8 @@ export class BrowserCacheManager extends CacheManager {
             this.clientId,
             result.tenantId,
             result.scopes.join(" "),
-            result.expiresOn?.getTime() || 0,
-            result.extExpiresOn?.getTime() || 0,
+            result.expiresOn ? result.expiresOn.getTime() / 1000 : 0,
+            result.extExpiresOn ? result.extExpiresOn.getTime() / 1000 : 0,
             base64Decode,
             undefined, // refreshOn
             result.tokenType as AuthenticationScheme,

package/src/config/Configuration.ts

@@ -94,7 +94,9 @@ export type BrowserAuthOptions = {
      */
     skipAuthorityMetadataCache?: boolean;
     /**
-     * App supports nested app auth or not; defaults to false
+     * App supports nested app auth or not; defaults to
+     *
+     * @deprecated This flag is deprecated and will be removed in the next major version. createNestablePublicClientApplication should be used instead.
      */
     supportsNestedAppAuth?: boolean;
 };

package/src/controllers/ControllerFactory.ts

@@ -3,10 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { TeamsAppOperatingContext } from "../operatingcontext/TeamsAppOperatingContext";
+import { NestedAppOperatingContext } from "../operatingcontext/NestedAppOperatingContext";
 import { StandardOperatingContext } from "../operatingcontext/StandardOperatingContext";
 import { IController } from "./IController";
 import { Configuration } from "../config/Configuration";
+import { StandardController } from "./StandardController";
+import { NestedAppAuthController } from "./NestedAppAuthController";
 
 export async function createV3Controller(
     config: Configuration
@@ -14,27 +16,23 @@ export async function createV3Controller(
     const standard = new StandardOperatingContext(config);
 
     await standard.initialize();
-
-    const controller = await import("./StandardController");
-    return controller.StandardController.createController(standard);
+    return StandardController.createController(standard);
 }
 
 export async function createController(
     config: Configuration
 ): Promise<IController | null> {
     const standard = new StandardOperatingContext(config);
-    const teamsApp = new TeamsAppOperatingContext(config);
+    const nestedApp = new NestedAppOperatingContext(config);
 
-    const operatingContexts = [standard.initialize(), teamsApp.initialize()];
+    const operatingContexts = [standard.initialize(), nestedApp.initialize()];
 
     await Promise.all(operatingContexts);
 
-    if (teamsApp.isAvailable()) {
-        const controller = await import("./NestedAppAuthController");
-        return controller.NestedAppAuthController.createController(teamsApp);
+    if (nestedApp.isAvailable() && config.auth.supportsNestedAppAuth) {
+        return NestedAppAuthController.createController(nestedApp);
     } else if (standard.isAvailable()) {
-        const controller = await import("./StandardController");
-        return controller.StandardController.createController(standard);
+        return StandardController.createController(standard);
     } else {
         // Since neither of the actual operating contexts are available keep the UnknownOperatingContextController
         return null;