@azure/msal-common 14.0.3 → 14.1.0

package/src/authority/AuthorityFactory.ts

@@ -4,14 +4,21 @@
  */
 
 import { Authority } from "./Authority";
-import { ClientConfigurationError } from "../error/ClientConfigurationError";
+import {
+    createClientConfigurationError,
+    ClientConfigurationErrorCodes,
+} from "../error/ClientConfigurationError";
 import { INetworkModule } from "../network/INetworkModule";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    createClientAuthError,
+    ClientAuthErrorCodes,
+} from "../error/ClientAuthError";
 import { ICacheManager } from "../cache/interface/ICacheManager";
 import { AuthorityOptions } from "./AuthorityOptions";
 import { Logger } from "../logger/Logger";
 import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient";
 import { PerformanceEvents } from "../telemetry/performance/PerformanceEvent";
+import { invokeAsync } from "../utils/FunctionWrappers";
 
 /** @internal */
 export class AuthorityFactory {
@@ -55,16 +62,19 @@ export class AuthorityFactory {
             );
 
         try {
-            performanceClient?.setPreQueueTime(
+            await invokeAsync(
+                acquireTokenAuthority.resolveEndpointsAsync.bind(
+                    acquireTokenAuthority
+                ),
                 PerformanceEvents.AuthorityResolveEndpointsAsync,
+                logger,
+                performanceClient,
                 correlationId
-            );
-
-            await acquireTokenAuthority.resolveEndpointsAsync();
+            )();
             return acquireTokenAuthority;
         } catch (e) {
-            throw ClientAuthError.createEndpointDiscoveryIncompleteError(
-                e as string
+            throw createClientAuthError(
+                ClientAuthErrorCodes.endpointResolutionError
             );
         }
     }
@@ -90,7 +100,9 @@ export class AuthorityFactory {
     ): Authority {
         // Throw error if authority url is empty
         if (!authorityUrl) {
-            throw ClientConfigurationError.createUrlEmptyError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.urlEmptyError
+            );
         }
 
         return new Authority(

package/src/authority/RegionDiscovery.ts

@@ -15,10 +15,14 @@ import { RegionDiscoveryMetadata } from "./RegionDiscoveryMetadata";
 import { ImdsOptions } from "./ImdsOptions";
 import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient";
 import { PerformanceEvents } from "../telemetry/performance/PerformanceEvent";
+import { invokeAsync } from "../utils/FunctionWrappers";
+import { Logger } from "../logger/Logger";
 
 export class RegionDiscovery {
     // Network interface to make requests with.
     protected networkInterface: INetworkModule;
+    // Logger
+    private logger: Logger;
     // Performance client
     protected performanceClient: IPerformanceClient | undefined;
     // CorrelationId
@@ -32,10 +36,12 @@ export class RegionDiscovery {
 
     constructor(
         networkInterface: INetworkModule,
+        logger: Logger,
         performanceClient?: IPerformanceClient,
         correlationId?: string
     ) {
         this.networkInterface = networkInterface;
+        this.logger = logger;
         this.performanceClient = performanceClient;
         this.correlationId = correlationId;
     }
@@ -62,14 +68,13 @@ export class RegionDiscovery {
             const options = RegionDiscovery.IMDS_OPTIONS;
 
             try {
-                this.performanceClient?.setPreQueueTime(
+                const localIMDSVersionResponse = await invokeAsync(
+                    this.getRegionFromIMDS.bind(this),
                     PerformanceEvents.RegionDiscoveryGetRegionFromIMDS,
+                    this.logger,
+                    this.performanceClient,
                     this.correlationId
-                );
-                const localIMDSVersionResponse = await this.getRegionFromIMDS(
-                    Constants.IMDS_VERSION,
-                    options
-                );
+                )(Constants.IMDS_VERSION, options);
                 if (
                     localIMDSVersionResponse.status ===
                     ResponseCodes.httpSuccess
@@ -84,28 +89,26 @@ export class RegionDiscovery {
                     localIMDSVersionResponse.status ===
                     ResponseCodes.httpBadRequest
                 ) {
-                    this.performanceClient?.setPreQueueTime(
+                    const currentIMDSVersion = await invokeAsync(
+                        this.getCurrentVersion.bind(this),
                         PerformanceEvents.RegionDiscoveryGetCurrentVersion,
+                        this.logger,
+                        this.performanceClient,
                         this.correlationId
-                    );
-                    const currentIMDSVersion = await this.getCurrentVersion(
-                        options
-                    );
+                    )(options);
                     if (!currentIMDSVersion) {
                         regionDiscoveryMetadata.region_source =
                             RegionDiscoverySources.FAILED_AUTO_DETECTION;
                         return null;
                     }
 
-                    this.performanceClient?.setPreQueueTime(
+                    const currentIMDSVersionResponse = await invokeAsync(
+                        this.getRegionFromIMDS.bind(this),
                         PerformanceEvents.RegionDiscoveryGetRegionFromIMDS,
+                        this.logger,
+                        this.performanceClient,
                         this.correlationId
-                    );
-                    const currentIMDSVersionResponse =
-                        await this.getRegionFromIMDS(
-                            currentIMDSVersion,
-                            options
-                        );
+                    )(currentIMDSVersion, options);
                     if (
                         currentIMDSVersionResponse.status ===
                         ResponseCodes.httpSuccess

package/src/cache/CacheManager.ts

@@ -26,9 +26,11 @@ import { AccountEntity } from "./entities/AccountEntity";
 import { AccessTokenEntity } from "./entities/AccessTokenEntity";
 import { IdTokenEntity } from "./entities/IdTokenEntity";
 import { RefreshTokenEntity } from "./entities/RefreshTokenEntity";
-import { AuthError } from "../error/AuthError";
 import { ICacheManager } from "./interface/ICacheManager";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    createClientAuthError,
+    ClientAuthErrorCodes,
+} from "../error/ClientAuthError";
 import { AccountInfo } from "../account/AccountInfo";
 import { AppMetadataEntity } from "./entities/AppMetadataEntity";
 import { ServerTelemetryEntity } from "./entities/ServerTelemetryEntity";
@@ -219,9 +221,19 @@ export abstract class CacheManager implements ICacheManager {
     ): string;
 
     /**
-     * Returns all accounts in cache
+     * 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
      */
-    getAllAccounts(): AccountInfo[] {
+    getAllAccounts(accountFilter?: AccountFilter): AccountInfo[] {
+        if (accountFilter) {
+            return this.getAccountsFilteredBy(accountFilter).map(
+                (accountEntity) => {
+                    return accountEntity.getAccountInfo();
+                }
+            );
+        }
+
         const allAccountKeys = this.getAccountKeys();
         if (allAccountKeys.length < 1) {
             return [];
@@ -240,16 +252,12 @@ export abstract class CacheManager implements ICacheManager {
             []
         );
 
-        if (accountEntities.length < 1) {
-            return [];
-        } else {
-            const allAccounts = accountEntities.map<AccountInfo>(
-                (accountEntity) => {
-                    return this.getAccountInfoFromEntity(accountEntity);
-                }
-            );
-            return allAccounts;
-        }
+        const allAccounts = accountEntities.map<AccountInfo>(
+            (accountEntity) => {
+                return this.getAccountInfoFromEntity(accountEntity);
+            }
+        );
+        return allAccounts;
     }
 
     /**
@@ -288,7 +296,9 @@ export abstract class CacheManager implements ICacheManager {
         storeInCache?: StoreInCache
     ): Promise<void> {
         if (!cacheRecord) {
-            throw ClientAuthError.createNullOrUndefinedCacheRecord();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.invalidCacheRecord
+            );
         }
 
         if (!!cacheRecord.account) {
@@ -360,11 +370,9 @@ export abstract class CacheManager implements ICacheManager {
     }
 
     /**
-     * retrieve accounts matching all provided filters; if no filter is set, get all accounts
-     * not checking for casing as keys are all generated in lower case, remember to convert to lower case if object properties are compared
-     * @param homeAccountId
-     * @param environment
-     * @param realm
+     * Retrieve accounts matching all provided filters; if no filter is set, get all accounts
+     * Not checking for casing as keys are all generated in lower case, remember to convert to lower case if object properties are compared
+     * @param accountFilter - An object containing Account properties to filter by
      */
     getAccountsFilteredBy(accountFilter: AccountFilter): AccountEntity[] {
         const allAccountKeys = this.getAccountKeys();
@@ -375,7 +383,7 @@ export abstract class CacheManager implements ICacheManager {
                 !this.isAccountKey(
                     cacheKey,
                     accountFilter.homeAccountId,
-                    accountFilter.realm
+                    accountFilter.tenantId
                 )
             ) {
                 // Don't parse value if the key doesn't match the account filters
@@ -423,6 +431,14 @@ export abstract class CacheManager implements ICacheManager {
                 return;
             }
 
+            // tenantId is another name for realm
+            if (
+                !!accountFilter.tenantId &&
+                !this.matchRealm(entity, accountFilter.tenantId)
+            ) {
+                return;
+            }
+
             if (
                 !!accountFilter.nativeAccountId &&
                 !this.matchNativeAccountId(
@@ -433,6 +449,27 @@ export abstract class CacheManager implements ICacheManager {
                 return;
             }
 
+            if (
+                !!accountFilter.loginHint &&
+                !this.matchLoginHint(entity, accountFilter.loginHint)
+            ) {
+                return;
+            }
+
+            if (
+                !!accountFilter.authorityType &&
+                !this.matchAuthorityType(entity, accountFilter.authorityType)
+            ) {
+                return;
+            }
+
+            if (
+                !!accountFilter.name &&
+                !this.matchName(entity, accountFilter.name)
+            ) {
+                return;
+            }
+
             matchingAccounts.push(entity);
         });
 
@@ -777,7 +814,9 @@ export abstract class CacheManager implements ICacheManager {
                     try {
                         await this.cryptoImpl.removeTokenBindingKey(kid);
                     } catch (error) {
-                        throw ClientAuthError.createBindingKeyNotRemovedError();
+                        throw createClientAuthError(
+                            ClientAuthErrorCodes.bindingKeyNotRemoved
+                        );
                     }
                 }
             }
@@ -1256,7 +1295,9 @@ export abstract class CacheManager implements ICacheManager {
         if (numAppMetadata < 1) {
             return null;
         } else if (numAppMetadata > 1) {
-            throw ClientAuthError.createMultipleMatchingAppMetadataInCacheError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.multipleMatchingAppMetadata
+            );
         }
 
         return appMetadataEntries[0] as AppMetadataEntity;
@@ -1316,6 +1357,16 @@ export abstract class CacheManager implements ICacheManager {
         );
     }
 
+    /**
+     * helper to match names
+     * @param entity
+     * @param name
+     * @returns true if the downcased name properties are present and match in the filter and the entity
+     */
+    private matchName(entity: AccountEntity, name: string): boolean {
+        return !!(name.toLowerCase() === entity.name?.toLowerCase());
+    }
+
     /**
      * helper to match assertion
      * @param value
@@ -1417,6 +1468,41 @@ export abstract class CacheManager implements ICacheManager {
         );
     }
 
+    /**
+     * helper to match loginHint which can be either:
+     * 1. login_hint ID token claim
+     * 2. username in cached account object
+     * 3. upn in ID token claims
+     * @param entity
+     * @param loginHint
+     * @returns
+     */
+    private matchLoginHint(entity: AccountEntity, loginHint: string): boolean {
+        if (entity.idTokenClaims?.login_hint === loginHint) {
+            return true;
+        }
+
+        if (entity.username === loginHint) {
+            return true;
+        }
+
+        if (entity.idTokenClaims?.upn === loginHint) {
+            return true;
+        }
+
+        return false;
+    }
+
+    private matchAuthorityType(
+        entity: AccountEntity,
+        authorityType: string
+    ): boolean {
+        return !!(
+            entity.authorityType &&
+            authorityType.toLowerCase() === entity.authorityType.toLowerCase()
+        );
+    }
+
     /**
      * Returns true if the target scopes are a subset of the current entity's scopes, false otherwise.
      * @param entity
@@ -1497,123 +1583,75 @@ export abstract class CacheManager implements ICacheManager {
 /** @internal */
 export class DefaultStorageClass extends CacheManager {
     setAccount(): void {
-        const notImplErr =
-            "Storage interface - setAccount() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getAccount(): AccountEntity {
-        const notImplErr =
-            "Storage interface - getAccount() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     setIdTokenCredential(): void {
-        const notImplErr =
-            "Storage interface - setIdTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getIdTokenCredential(): IdTokenEntity {
-        const notImplErr =
-            "Storage interface - getIdTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     setAccessTokenCredential(): void {
-        const notImplErr =
-            "Storage interface - setAccessTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getAccessTokenCredential(): AccessTokenEntity {
-        const notImplErr =
-            "Storage interface - getAccessTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     setRefreshTokenCredential(): void {
-        const notImplErr =
-            "Storage interface - setRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getRefreshTokenCredential(): RefreshTokenEntity {
-        const notImplErr =
-            "Storage interface - getRefreshTokenCredential() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     setAppMetadata(): void {
-        const notImplErr =
-            "Storage interface - setAppMetadata() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getAppMetadata(): AppMetadataEntity {
-        const notImplErr =
-            "Storage interface - getAppMetadata() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     setServerTelemetry(): void {
-        const notImplErr =
-            "Storage interface - setServerTelemetry() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getServerTelemetry(): ServerTelemetryEntity {
-        const notImplErr =
-            "Storage interface - getServerTelemetry() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     setAuthorityMetadata(): void {
-        const notImplErr =
-            "Storage interface - setAuthorityMetadata() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getAuthorityMetadata(): AuthorityMetadataEntity | null {
-        const notImplErr =
-            "Storage interface - getAuthorityMetadata() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getAuthorityMetadataKeys(): Array<string> {
-        const notImplErr =
-            "Storage interface - getAuthorityMetadataKeys() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     setThrottlingCache(): void {
-        const notImplErr =
-            "Storage interface - setThrottlingCache() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getThrottlingCache(): ThrottlingEntity {
-        const notImplErr =
-            "Storage interface - getThrottlingCache() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     removeItem(): boolean {
-        const notImplErr =
-            "Storage interface - removeItem() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     containsKey(): boolean {
-        const notImplErr =
-            "Storage interface - containsKey() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getKeys(): string[] {
-        const notImplErr =
-            "Storage interface - getKeys() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getAccountKeys(): string[] {
-        const notImplErr =
-            "Storage interface - getAccountKeys() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     getTokenKeys(): TokenKeys {
-        const notImplErr =
-            "Storage interface - getTokenKeys() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     async clear(): Promise<void> {
-        const notImplErr =
-            "Storage interface - clear() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
     updateCredentialCacheKey(): string {
-        const notImplErr =
-            "Storage interface - updateCredentialCacheKey() has not been implemented for the cacheStorage interface.";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     }
 }

package/src/cache/entities/AccessTokenEntity.ts

@@ -8,7 +8,10 @@ import { CredentialType, AuthenticationScheme } from "../../utils/Constants";
 import { TimeUtils } from "../../utils/TimeUtils";
 import { ICrypto } from "../../crypto/ICrypto";
 import { TokenClaims } from "../../account/TokenClaims";
-import { ClientAuthError } from "../../error/ClientAuthError";
+import {
+    createClientAuthError,
+    ClientAuthErrorCodes,
+} from "../../error/ClientAuthError";
 import { extractTokenClaims } from "../../account/AuthToken";
 
 /**
@@ -125,7 +128,9 @@ export class AccessTokenEntity extends CredentialEntity {
                         cryptoUtils.base64Decode
                     );
                     if (!tokenClaims?.cnf?.kid) {
-                        throw ClientAuthError.createTokenClaimsRequiredError();
+                        throw createClientAuthError(
+                            ClientAuthErrorCodes.tokenClaimsCnfRequiredForSignedJwt
+                        );
                     }
                     atEntity.keyId = tokenClaims.cnf.kid;
                     break;

package/src/cache/entities/AccountEntity.ts

@@ -8,7 +8,10 @@ import { Authority } from "../../authority/Authority";
 import { ICrypto } from "../../crypto/ICrypto";
 import { buildClientInfo } from "../../account/ClientInfo";
 import { AccountInfo } from "../../account/AccountInfo";
-import { ClientAuthError } from "../../error/ClientAuthError";
+import {
+    createClientAuthError,
+    ClientAuthErrorCodes,
+} from "../../error/ClientAuthError";
 import { AuthorityType } from "../../authority/AuthorityType";
 import { Logger } from "../../logger/Logger";
 import { TokenClaims } from "../../account/TokenClaims";
@@ -140,7 +143,9 @@ export class AccountEntity {
             (authority && authority.getPreferredCache());
 
         if (!env) {
-            throw ClientAuthError.createInvalidCacheEnvironmentError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.invalidCacheEnvironment
+            );
         }
 
         account.environment = env;

package/src/cache/entities/CredentialEntity.ts

@@ -10,7 +10,10 @@ import {
     Constants,
     AuthenticationScheme,
 } from "../../utils/Constants";
-import { ClientAuthError } from "../../error/ClientAuthError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../../error/ClientAuthError";
 
 /**
  * Base type for credentials to be stored in the cache: eg: ACCESS_TOKEN, ID_TOKEN etc
@@ -107,7 +110,9 @@ export class CredentialEntity {
             case CredentialType.REFRESH_TOKEN:
                 return CacheType.REFRESH_TOKEN;
             default: {
-                throw ClientAuthError.createUnexpectedCredentialTypeError();
+                throw createClientAuthError(
+                    ClientAuthErrorCodes.unexpectedCredentialType
+                );
             }
         }
     }

package/src/cache/utils/CacheTypes.ts

@@ -13,6 +13,7 @@ import { ThrottlingEntity } from "../entities/ThrottlingEntity";
 import { AuthorityMetadataEntity } from "../entities/AuthorityMetadataEntity";
 import { AuthenticationScheme } from "../../utils/Constants";
 import { ScopeSet } from "../../request/ScopeSet";
+import { AccountInfo } from "../../account/AccountInfo";
 
 /** @internal */
 export type AccountCache = Record<string, AccountEntity>;
@@ -52,13 +53,12 @@ export type ValidCredentialType =
 /**
  * Account:	<home_account_id>-<environment>-<realm*>
  */
-export type AccountFilter = {
-    homeAccountId?: string;
-    localAccountId?: string;
-    username?: string;
-    environment?: string;
+export type AccountFilter = Omit<
+    Partial<AccountInfo>,
+    "idToken" | "idTokenClaims"
+> & {
     realm?: string;
-    nativeAccountId?: string;
+    loginHint?: string;
 };
 
 /**