@azure/msal-common 14.1.0 → 14.3.0

package/dist/cache/entities/AccessTokenEntity.mjs

@@ -1,121 +0,0 @@
-/*! @azure/msal-common v14.1.0 2023-10-05 */
-'use strict';
-import { CredentialEntity } from './CredentialEntity.mjs';
-import { CredentialType, AuthenticationScheme } from '../../utils/Constants.mjs';
-import { TimeUtils } from '../../utils/TimeUtils.mjs';
-import { createClientAuthError } from '../../error/ClientAuthError.mjs';
-import { extractTokenClaims } from '../../account/AuthToken.mjs';
-import { tokenClaimsCnfRequiredForSignedJwt } from '../../error/ClientAuthErrorCodes.mjs';
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * ACCESS_TOKEN Credential Type
- *
- * Key:Value Schema:
- *
- * Key Example: uid.utid-login.microsoftonline.com-accesstoken-clientId-contoso.com-user.read
- *
- * Value Schema:
- * {
- *      homeAccountId: home account identifier for the auth scheme,
- *      environment: entity that issued the token, represented as a full host
- *      credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other
- *      clientId: client ID of the application
- *      secret: Actual credential as a string
- *      familyId: Family ID identifier, usually only used for refresh tokens
- *      realm: Full tenant or organizational identifier that the account belongs to
- *      target: Permissions that are included in the token, or for refresh tokens, the resource identifier.
- *      cachedAt: Absolute device time when entry was created in the cache.
- *      expiresOn: Token expiry time, calculated based on current UTC time in seconds. Represented as a string.
- *      extendedExpiresOn: Additional extended expiry time until when token is valid in case of server-side outage. Represented as string in UTC seconds.
- *      keyId: used for POP and SSH tokenTypes
- *      tokenType: Type of the token issued. Usually "Bearer"
- * }
- */
-class AccessTokenEntity extends CredentialEntity {
-    /**
-     * Create AccessTokenEntity
-     * @param homeAccountId
-     * @param environment
-     * @param accessToken
-     * @param clientId
-     * @param tenantId
-     * @param scopes
-     * @param expiresOn
-     * @param extExpiresOn
-     */
-    static createAccessTokenEntity(homeAccountId, environment, accessToken, clientId, tenantId, scopes, expiresOn, extExpiresOn, cryptoUtils, refreshOn, tokenType, userAssertionHash, keyId, requestedClaims, requestedClaimsHash) {
-        const atEntity = new AccessTokenEntity();
-        atEntity.homeAccountId = homeAccountId;
-        atEntity.credentialType = CredentialType.ACCESS_TOKEN;
-        atEntity.secret = accessToken;
-        const currentTime = TimeUtils.nowSeconds();
-        atEntity.cachedAt = currentTime.toString();
-        /*
-         * Token expiry time.
-         * This value should be  calculated based on the current UTC time measured locally and the value  expires_in Represented as a string in JSON.
-         */
-        atEntity.expiresOn = expiresOn.toString();
-        atEntity.extendedExpiresOn = extExpiresOn.toString();
-        if (refreshOn) {
-            atEntity.refreshOn = refreshOn.toString();
-        }
-        atEntity.environment = environment;
-        atEntity.clientId = clientId;
-        atEntity.realm = tenantId;
-        atEntity.target = scopes;
-        atEntity.userAssertionHash = userAssertionHash;
-        atEntity.tokenType = tokenType || AuthenticationScheme.BEARER;
-        if (requestedClaims) {
-            atEntity.requestedClaims = requestedClaims;
-            atEntity.requestedClaimsHash = requestedClaimsHash;
-        }
-        /*
-         * Create Access Token With Auth Scheme instead of regular access token
-         * Cast to lower to handle "bearer" from ADFS
-         */
-        if (atEntity.tokenType?.toLowerCase() !==
-            AuthenticationScheme.BEARER.toLowerCase()) {
-            atEntity.credentialType =
-                CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME;
-            switch (atEntity.tokenType) {
-                case AuthenticationScheme.POP:
-                    // Make sure keyId is present and add it to credential
-                    const tokenClaims = extractTokenClaims(accessToken, cryptoUtils.base64Decode);
-                    if (!tokenClaims?.cnf?.kid) {
-                        throw createClientAuthError(tokenClaimsCnfRequiredForSignedJwt);
-                    }
-                    atEntity.keyId = tokenClaims.cnf.kid;
-                    break;
-                case AuthenticationScheme.SSH:
-                    atEntity.keyId = keyId;
-            }
-        }
-        return atEntity;
-    }
-    /**
-     * Validates an entity: checks for all expected params
-     * @param entity
-     */
-    static isAccessTokenEntity(entity) {
-        if (!entity) {
-            return false;
-        }
-        return (entity.hasOwnProperty("homeAccountId") &&
-            entity.hasOwnProperty("environment") &&
-            entity.hasOwnProperty("credentialType") &&
-            entity.hasOwnProperty("realm") &&
-            entity.hasOwnProperty("clientId") &&
-            entity.hasOwnProperty("secret") &&
-            entity.hasOwnProperty("target") &&
-            (entity["credentialType"] === CredentialType.ACCESS_TOKEN ||
-                entity["credentialType"] ===
-                    CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME));
-    }
-}
-
-export { AccessTokenEntity };
-//# sourceMappingURL=AccessTokenEntity.mjs.map

package/dist/cache/entities/AccessTokenEntity.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccessTokenEntity.mjs","sources":["../../../src/cache/entities/AccessTokenEntity.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;AAKA;AACA;AAEA;AAQA;;;;;;;;;;;;;;;;;;AAuBG;AACH;;;;;;AAMa,MAAA,iBAAU,SAAA,gBAAA,CAAA;;;;;AAMnB;;;;;;;;;;AAUG,QAAA,QAAA,CAAA,cAAA,GAAA,cAAA,CAAA,YAAA,CAAA;AACH,QAAA,QAAO,CAAA,MAAA,GAAA,WACH,CAAA;AAgFJ,QAAA,MAAA,WAAA,GAAA,SAAA,CAAA,UAAA,EAAA,CAAA;;;AAGG;AACH;AAkBH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cache/entities/CredentialEntity.mjs

@@ -1,145 +0,0 @@
-/*! @azure/msal-common v14.1.0 2023-10-05 */
-'use strict';
-import { CredentialType, CacheType, Separators, Constants, AuthenticationScheme } from '../../utils/Constants.mjs';
-import { createClientAuthError } from '../../error/ClientAuthError.mjs';
-import { unexpectedCredentialType } from '../../error/ClientAuthErrorCodes.mjs';
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Base type for credentials to be stored in the cache: eg: ACCESS_TOKEN, ID_TOKEN etc
- *
- * Key:Value Schema:
- *
- * Key: <home_account_id*>-<environment>-<credential_type>-<client_id>-<realm*>-<target*>-<requestedClaims*>-<scheme*>
- *
- * Value Schema:
- * {
- *      homeAccountId: home account identifier for the auth scheme,
- *      environment: entity that issued the token, represented as a full host
- *      credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other
- *      clientId: client ID of the application
- *      secret: Actual credential as a string
- *      familyId: Family ID identifier, usually only used for refresh tokens
- *      realm: Full tenant or organizational identifier that the account belongs to
- *      target: Permissions that are included in the token, or for refresh tokens, the resource identifier.
- *      tokenType: Matches the authentication scheme for which the token was issued (i.e. Bearer or pop)
- *      requestedClaimsHash: Matches the SHA 256 hash of the claims object included in the token request
- *      userAssertionHash: Matches the SHA 256 hash of the obo_assertion for the OBO flow
- * }
- */
-class CredentialEntity {
-    /**
-     * Generate Account Id key component as per the schema: <home_account_id>-<environment>
-     */
-    generateAccountId() {
-        return CredentialEntity.generateAccountIdForCacheKey(this.homeAccountId, this.environment);
-    }
-    /**
-     * Generate Credential Id key component as per the schema: <credential_type>-<client_id>-<realm>
-     */
-    generateCredentialId() {
-        return CredentialEntity.generateCredentialIdForCacheKey(this.credentialType, this.clientId, this.realm, this.familyId);
-    }
-    /**
-     * Generate target key component as per schema: <target>
-     */
-    generateTarget() {
-        return CredentialEntity.generateTargetForCacheKey(this.target);
-    }
-    /**
-     * generates credential key
-     */
-    generateCredentialKey() {
-        return CredentialEntity.generateCredentialCacheKey(this.homeAccountId, this.environment, this.credentialType, this.clientId, this.realm, this.target, this.familyId, this.tokenType, this.requestedClaimsHash);
-    }
-    /**
-     * returns the type of the cache (in this case credential)
-     */
-    generateType() {
-        switch (this.credentialType) {
-            case CredentialType.ID_TOKEN:
-                return CacheType.ID_TOKEN;
-            case CredentialType.ACCESS_TOKEN:
-            case CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME:
-                return CacheType.ACCESS_TOKEN;
-            case CredentialType.REFRESH_TOKEN:
-                return CacheType.REFRESH_TOKEN;
-            default: {
-                throw createClientAuthError(unexpectedCredentialType);
-            }
-        }
-    }
-    /**
-     * generates credential key
-     * <home_account_id*>-\<environment>-<credential_type>-<client_id>-<realm\*>-<target\*>-<scheme\*>
-     */
-    static generateCredentialCacheKey(homeAccountId, environment, credentialType, clientId, realm, target, familyId, tokenType, requestedClaimsHash) {
-        const credentialKey = [
-            this.generateAccountIdForCacheKey(homeAccountId, environment),
-            this.generateCredentialIdForCacheKey(credentialType, clientId, realm, familyId),
-            this.generateTargetForCacheKey(target),
-            this.generateClaimsHashForCacheKey(requestedClaimsHash),
-            this.generateSchemeForCacheKey(tokenType),
-        ];
-        return credentialKey.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
-    }
-    /**
-     * generates Account Id for keys
-     * @param homeAccountId
-     * @param environment
-     */
-    static generateAccountIdForCacheKey(homeAccountId, environment) {
-        const accountId = [homeAccountId, environment];
-        return accountId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
-    }
-    /**
-     * Generates Credential Id for keys
-     * @param credentialType
-     * @param realm
-     * @param clientId
-     * @param familyId
-     */
-    static generateCredentialIdForCacheKey(credentialType, clientId, realm, familyId) {
-        const clientOrFamilyId = credentialType === CredentialType.REFRESH_TOKEN
-            ? familyId || clientId
-            : clientId;
-        const credentialId = [
-            credentialType,
-            clientOrFamilyId,
-            realm || Constants.EMPTY_STRING,
-        ];
-        return credentialId.join(Separators.CACHE_KEY_SEPARATOR).toLowerCase();
-    }
-    /**
-     * Generate target key component as per schema: <target>
-     */
-    static generateTargetForCacheKey(scopes) {
-        return (scopes || Constants.EMPTY_STRING).toLowerCase();
-    }
-    /**
-     * Generate requested claims key component as per schema: <requestedClaims>
-     */
-    static generateClaimsHashForCacheKey(requestedClaimsHash) {
-        return (requestedClaimsHash || Constants.EMPTY_STRING).toLowerCase();
-    }
-    /**
-     * Generate scheme key componenet as per schema: <scheme>
-     */
-    static generateSchemeForCacheKey(tokenType) {
-        /*
-         * PoP Tokens and SSH certs include scheme in cache key
-         * Cast to lowercase to handle "bearer" from ADFS
-         */
-        return tokenType &&
-            tokenType.toLowerCase() !==
-                AuthenticationScheme.BEARER.toLowerCase()
-            ? tokenType.toLowerCase()
-            : Constants.EMPTY_STRING;
-    }
-}
-
-export { CredentialEntity };
-//# sourceMappingURL=CredentialEntity.mjs.map

package/dist/cache/entities/CredentialEntity.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"CredentialEntity.mjs","sources":["../../../src/cache/entities/CredentialEntity.ts"],"sourcesContent":[null],"names":["ClientAuthErrorCodes.unexpectedCredentialType"],"mappings":";;;;;;AAKA;AAYA;;;;;;;;;;;;;;;;;;;AAqBG;AACH;;;;;AAKU,sBAAS,CAAA;;;;IAIf,iBAAiB,GAAG;QACX,OAAG,gBAAA,CAAA,4BAAqB,CAAA,IAAA,CAAA,aAAA,EAAA,IAAA,CAAA,WAAA,CAAA,CAAA;KAC5B;;AAGL;;AAEG,IAAA,oBAAA,GAAA;AACH,QAAA,OAAA,gBAA2B,CAAA,+BAAA,CAAA,IAAA,CAAA,cAAA,EAAA,IAAA,CAAA,QAAA,EAAA,IAAA,CAAA,KAAA,EAAA,IAAA,CAAA,QAAA,CAAA,CAAA;AAO3B,KAAA;;AAEG;AACH;AASA,IAAA,cAAA,GAAA;;AAEG,KAAA;AACH;AAIA;;AAEG,IAAA,qBAAA,GAAA;AACH,QAAA,OAAA,gBAA+B,CAAA,0BAAA,CAAA,IAAA,CAAA,aAAA,EAAA,IAAA,CAAA,WAAA,EAAA,IAAA,CAAA,cAAA,EAAA,IAAA,CAAA,QAAA,EAAA,IAAA,CAAA,KAAA,EAAA,IAAA,CAAA,MAAA,EAAA,IAAA,CAAA,QAAA,EAAA,IAAA,CAAA,SAAA,EAAA,IAAA,CAAA,mBAAA,CAAA,CAAA;AAc/B,KAAA;;AAEG;AACH;AAiBA,IAAA,YAAA,GAAA;;;AAGG,gBAAA,OAAA,SAAA,CAAA,QAAA,CAAA;4CAEC,CAAA;AA0BJ,YAAA,KAAA,cAAA,CAAA,6BAAA;;;;AAIG,YAAA,SAAA;gBACW,MAA6B,qBAAA,CAAAA,wBAAA,CAAA,CAAA;AAQ3C,aAAA;;;;;;AAMG;IACH,OAAO,0BAAuC,CAAA,aAAA,EAAA,WAAA,EAAA,cAAA,EAAA,QAAA,EAAA,KAAA,EAAA,MAAA,EAAA,QAAA,EAAA,SAAA,EAAA,mBAAA,EAAA;AAmB9C,QAAA,MAAA,aAAA,GAAA;;AAEG,YAAA,IAAA,CAAA,+BAAA,CAAA,cAAA,EAAA,QAAA,EAAA,KAAA,EAAA,QAAA,CAAA;YACK,IAAM,CAAA,yBAA0B,CAAA,MAAA,CAAA;AAIxC,YAAA,IAAA,CAAA,6BAAA,CAAA,mBAAA,CAAA;;AAEG,SAAA,CAAA;QACI,OAAO,aAA8B,CAAA,IAAA,CAAA,UAAA,CAAA,mBAAA,CAAA,CAAA,WAAA,EAAA,CAAA;AAM5C,KAAA;;AAEG;;AAYN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cache/entities/IdTokenEntity.mjs

@@ -1,64 +0,0 @@
-/*! @azure/msal-common v14.1.0 2023-10-05 */
-'use strict';
-import { CredentialEntity } from './CredentialEntity.mjs';
-import { CredentialType } from '../../utils/Constants.mjs';
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * ID_TOKEN Cache
- *
- * Key:Value Schema:
- *
- * Key Example: uid.utid-login.microsoftonline.com-idtoken-clientId-contoso.com-
- *
- * Value Schema:
- * {
- *      homeAccountId: home account identifier for the auth scheme,
- *      environment: entity that issued the token, represented as a full host
- *      credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other
- *      clientId: client ID of the application
- *      secret: Actual credential as a string
- *      realm: Full tenant or organizational identifier that the account belongs to
- * }
- */
-class IdTokenEntity extends CredentialEntity {
-    /**
-     * Create IdTokenEntity
-     * @param homeAccountId
-     * @param authenticationResult
-     * @param clientId
-     * @param authority
-     */
-    static createIdTokenEntity(homeAccountId, environment, idToken, clientId, tenantId) {
-        const idTokenEntity = new IdTokenEntity();
-        idTokenEntity.credentialType = CredentialType.ID_TOKEN;
-        idTokenEntity.homeAccountId = homeAccountId;
-        idTokenEntity.environment = environment;
-        idTokenEntity.clientId = clientId;
-        idTokenEntity.secret = idToken;
-        idTokenEntity.realm = tenantId;
-        return idTokenEntity;
-    }
-    /**
-     * Validates an entity: checks for all expected params
-     * @param entity
-     */
-    static isIdTokenEntity(entity) {
-        if (!entity) {
-            return false;
-        }
-        return (entity.hasOwnProperty("homeAccountId") &&
-            entity.hasOwnProperty("environment") &&
-            entity.hasOwnProperty("credentialType") &&
-            entity.hasOwnProperty("realm") &&
-            entity.hasOwnProperty("clientId") &&
-            entity.hasOwnProperty("secret") &&
-            entity["credentialType"] === CredentialType.ID_TOKEN);
-    }
-}
-
-export { IdTokenEntity };
-//# sourceMappingURL=IdTokenEntity.mjs.map

package/dist/cache/entities/IdTokenEntity.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"IdTokenEntity.mjs","sources":["../../../src/cache/entities/IdTokenEntity.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAKA;AAGA;;;;;;;;;;;;;;AAgBG;AACH;;AAGI;;;;;;AAMG;;AAoBH;;;AAGG,IAAA,OAAA,mBAAA,CAAA,aAAA,EAAA,WAAA,EAAA,OAAA,EAAA,QAAA,EAAA,QAAA,EAAA;AACH,QAAA,MAAsB,aAAC,OAAQ,aAAgB,EAAA,CAAA;AAelD,QAAA,aAAA,CAAA,cAAA,GAAA,cAAA,CAAA,QAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cache/entities/RefreshTokenEntity.mjs

@@ -1,67 +0,0 @@
-/*! @azure/msal-common v14.1.0 2023-10-05 */
-'use strict';
-import { CredentialEntity } from './CredentialEntity.mjs';
-import { CredentialType } from '../../utils/Constants.mjs';
-
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * REFRESH_TOKEN Cache
- *
- * Key:Value Schema:
- *
- * Key Example: uid.utid-login.microsoftonline.com-refreshtoken-clientId--
- *
- * Value:
- * {
- *      homeAccountId: home account identifier for the auth scheme,
- *      environment: entity that issued the token, represented as a full host
- *      credentialType: Type of credential as a string, can be one of the following: RefreshToken, AccessToken, IdToken, Password, Cookie, Certificate, Other
- *      clientId: client ID of the application
- *      secret: Actual credential as a string
- *      familyId: Family ID identifier, '1' represents Microsoft Family
- *      realm: Full tenant or organizational identifier that the account belongs to
- *      target: Permissions that are included in the token, or for refresh tokens, the resource identifier.
- * }
- */
-class RefreshTokenEntity extends CredentialEntity {
-    /**
-     * Create RefreshTokenEntity
-     * @param homeAccountId
-     * @param authenticationResult
-     * @param clientId
-     * @param authority
-     */
-    static createRefreshTokenEntity(homeAccountId, environment, refreshToken, clientId, familyId, userAssertionHash) {
-        const rtEntity = new RefreshTokenEntity();
-        rtEntity.clientId = clientId;
-        rtEntity.credentialType = CredentialType.REFRESH_TOKEN;
-        rtEntity.environment = environment;
-        rtEntity.homeAccountId = homeAccountId;
-        rtEntity.secret = refreshToken;
-        rtEntity.userAssertionHash = userAssertionHash;
-        if (familyId)
-            rtEntity.familyId = familyId;
-        return rtEntity;
-    }
-    /**
-     * Validates an entity: checks for all expected params
-     * @param entity
-     */
-    static isRefreshTokenEntity(entity) {
-        if (!entity) {
-            return false;
-        }
-        return (entity.hasOwnProperty("homeAccountId") &&
-            entity.hasOwnProperty("environment") &&
-            entity.hasOwnProperty("credentialType") &&
-            entity.hasOwnProperty("clientId") &&
-            entity.hasOwnProperty("secret") &&
-            entity["credentialType"] === CredentialType.REFRESH_TOKEN);
-    }
-}
-
-export { RefreshTokenEntity };
-//# sourceMappingURL=RefreshTokenEntity.mjs.map

package/dist/cache/entities/RefreshTokenEntity.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"RefreshTokenEntity.mjs","sources":["../../../src/cache/entities/RefreshTokenEntity.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAKA;AAGA;;;;;;;;;;;;;;;;AAkBG;AACH;;AAGI;;;;;;AAMG;AACH;AAsBA;;;AAGG,IAAA,OAAA,wBAAA,CAAA,aAAA,EAAA,WAAA,EAAA,YAAA,EAAA,QAAA,EAAA,QAAA,EAAA,iBAAA,EAAA;AACH,QAAA,MAA2B,QAAA,GAAA,IAAA,oBAAkB,CAAO;AAcvD,QAAA,QAAA,CAAA,QAAA,GAAA,QAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}