@azure/msal-common 15.12.0 → 16.0.0-alpha.0

package/src/error/CacheError.ts

@@ -3,20 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import { AuthError } from "./AuthError.js";
 import * as CacheErrorCodes from "./CacheErrorCodes.js";
+import { getDefaultErrorMessage } from "./AuthError.js";
 export { CacheErrorCodes };
 
-export const CacheErrorMessages = {
-    [CacheErrorCodes.cacheQuotaExceeded]: "Exceeded cache storage capacity.",
-    [CacheErrorCodes.cacheErrorUnknown]:
-        "Unexpected error occurred when using cache storage.",
-};
-
 /**
  * Error thrown when there is an error with the cache
  */
-export class CacheError extends AuthError {
+export class CacheError extends Error {
     /**
      * Short string denoting error
      */
@@ -28,13 +22,8 @@ export class CacheError extends AuthError {
     errorMessage: string;
 
     constructor(errorCode: string, errorMessage?: string) {
-        const message =
-            errorMessage ||
-            (CacheErrorMessages[errorCode]
-                ? CacheErrorMessages[errorCode]
-                : CacheErrorMessages[CacheErrorCodes.cacheErrorUnknown]);
-
-        super(`${errorCode}: ${message}`);
+        const message = errorMessage || getDefaultErrorMessage(errorCode);
+        super(message);
         Object.setPrototypeOf(this, CacheError.prototype);
 
         this.name = "CacheError";

package/src/error/ClientAuthError.ts

@@ -11,322 +11,12 @@ export { ClientAuthErrorCodes }; // Allow importing as "ClientAuthErrorCodes";
  * ClientAuthErrorMessage class containing string constants used by error codes and messages.
  */
 
-export const ClientAuthErrorMessages = {
-    [ClientAuthErrorCodes.clientInfoDecodingError]:
-        "The client info could not be parsed/decoded correctly",
-    [ClientAuthErrorCodes.clientInfoEmptyError]: "The client info was empty",
-    [ClientAuthErrorCodes.tokenParsingError]: "Token cannot be parsed",
-    [ClientAuthErrorCodes.nullOrEmptyToken]: "The token is null or empty",
-    [ClientAuthErrorCodes.endpointResolutionError]:
-        "Endpoints cannot be resolved",
-    [ClientAuthErrorCodes.networkError]: "Network request failed",
-    [ClientAuthErrorCodes.openIdConfigError]:
-        "Could not retrieve endpoints. Check your authority and verify the .well-known/openid-configuration endpoint returns the required endpoints.",
-    [ClientAuthErrorCodes.hashNotDeserialized]:
-        "The hash parameters could not be deserialized",
-    [ClientAuthErrorCodes.invalidState]: "State was not the expected format",
-    [ClientAuthErrorCodes.stateMismatch]: "State mismatch error",
-    [ClientAuthErrorCodes.stateNotFound]: "State not found",
-    [ClientAuthErrorCodes.nonceMismatch]: "Nonce mismatch error",
-    [ClientAuthErrorCodes.authTimeNotFound]:
-        "Max Age was requested and the ID token is missing the auth_time variable." +
-        " auth_time is an optional claim and is not enabled by default - it must be enabled." +
-        " See https://aka.ms/msaljs/optional-claims for more information.",
-    [ClientAuthErrorCodes.maxAgeTranspired]:
-        "Max Age is set to 0, or too much time has elapsed since the last end-user authentication.",
-    [ClientAuthErrorCodes.multipleMatchingTokens]:
-        "The cache contains multiple tokens satisfying the requirements. " +
-        "Call AcquireToken again providing more requirements such as authority or account.",
-    [ClientAuthErrorCodes.multipleMatchingAccounts]:
-        "The cache contains multiple accounts satisfying the given parameters. Please pass more info to obtain the correct account",
-    [ClientAuthErrorCodes.multipleMatchingAppMetadata]:
-        "The cache contains multiple appMetadata satisfying the given parameters. Please pass more info to obtain the correct appMetadata",
-    [ClientAuthErrorCodes.requestCannotBeMade]:
-        "Token request cannot be made without authorization code or refresh token.",
-    [ClientAuthErrorCodes.cannotRemoveEmptyScope]:
-        "Cannot remove null or empty scope from ScopeSet",
-    [ClientAuthErrorCodes.cannotAppendScopeSet]: "Cannot append ScopeSet",
-    [ClientAuthErrorCodes.emptyInputScopeSet]:
-        "Empty input ScopeSet cannot be processed",
-    [ClientAuthErrorCodes.deviceCodePollingCancelled]:
-        "Caller has cancelled token endpoint polling during device code flow by setting DeviceCodeRequest.cancel = true.",
-    [ClientAuthErrorCodes.deviceCodeExpired]: "Device code is expired.",
-    [ClientAuthErrorCodes.deviceCodeUnknownError]:
-        "Device code stopped polling for unknown reasons.",
-    [ClientAuthErrorCodes.noAccountInSilentRequest]:
-        "Please pass an account object, silent flow is not supported without account information",
-    [ClientAuthErrorCodes.invalidCacheRecord]:
-        "Cache record object was null or undefined.",
-    [ClientAuthErrorCodes.invalidCacheEnvironment]:
-        "Invalid environment when attempting to create cache entry",
-    [ClientAuthErrorCodes.noAccountFound]:
-        "No account found in cache for given key.",
-    [ClientAuthErrorCodes.noCryptoObject]: "No crypto object detected.",
-    [ClientAuthErrorCodes.unexpectedCredentialType]:
-        "Unexpected credential type.",
-    [ClientAuthErrorCodes.invalidAssertion]:
-        "Client assertion must meet requirements described in https://tools.ietf.org/html/rfc7515",
-    [ClientAuthErrorCodes.invalidClientCredential]:
-        "Client credential (secret, certificate, or assertion) must not be empty when creating a confidential client. An application should at most have one credential",
-    [ClientAuthErrorCodes.tokenRefreshRequired]:
-        "Cannot return token from cache because it must be refreshed. This may be due to one of the following reasons: forceRefresh parameter is set to true, claims have been requested, there is no cached access token or it is expired.",
-    [ClientAuthErrorCodes.userTimeoutReached]:
-        "User defined timeout for device code polling reached",
-    [ClientAuthErrorCodes.tokenClaimsCnfRequiredForSignedJwt]:
-        "Cannot generate a POP jwt if the token_claims are not populated",
-    [ClientAuthErrorCodes.authorizationCodeMissingFromServerResponse]:
-        "Server response does not contain an authorization code to proceed",
-    [ClientAuthErrorCodes.bindingKeyNotRemoved]:
-        "Could not remove the credential's binding key from storage.",
-    [ClientAuthErrorCodes.endSessionEndpointNotSupported]:
-        "The provided authority does not support logout",
-    [ClientAuthErrorCodes.keyIdMissing]:
-        "A keyId value is missing from the requested bound token's cache record and is required to match the token to it's stored binding key.",
-    [ClientAuthErrorCodes.noNetworkConnectivity]:
-        "No network connectivity. Check your internet connection.",
-    [ClientAuthErrorCodes.userCanceled]: "User cancelled the flow.",
-    [ClientAuthErrorCodes.missingTenantIdError]:
-        "A tenant id - not common, organizations, or consumers - must be specified when using the client_credentials flow.",
-    [ClientAuthErrorCodes.methodNotImplemented]:
-        "This method has not been implemented",
-    [ClientAuthErrorCodes.nestedAppAuthBridgeDisabled]:
-        "The nested app auth bridge is disabled",
-};
-
-/**
- * String constants used by error codes and messages.
- * @deprecated Use ClientAuthErrorCodes instead
- */
-export const ClientAuthErrorMessage = {
-    clientInfoDecodingError: {
-        code: ClientAuthErrorCodes.clientInfoDecodingError,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.clientInfoDecodingError
-        ],
-    },
-    clientInfoEmptyError: {
-        code: ClientAuthErrorCodes.clientInfoEmptyError,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.clientInfoEmptyError
-        ],
-    },
-    tokenParsingError: {
-        code: ClientAuthErrorCodes.tokenParsingError,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.tokenParsingError],
-    },
-    nullOrEmptyToken: {
-        code: ClientAuthErrorCodes.nullOrEmptyToken,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.nullOrEmptyToken],
-    },
-    endpointResolutionError: {
-        code: ClientAuthErrorCodes.endpointResolutionError,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.endpointResolutionError
-        ],
-    },
-    networkError: {
-        code: ClientAuthErrorCodes.networkError,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.networkError],
-    },
-    unableToGetOpenidConfigError: {
-        code: ClientAuthErrorCodes.openIdConfigError,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.openIdConfigError],
-    },
-    hashNotDeserialized: {
-        code: ClientAuthErrorCodes.hashNotDeserialized,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.hashNotDeserialized],
-    },
-    invalidStateError: {
-        code: ClientAuthErrorCodes.invalidState,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.invalidState],
-    },
-    stateMismatchError: {
-        code: ClientAuthErrorCodes.stateMismatch,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.stateMismatch],
-    },
-    stateNotFoundError: {
-        code: ClientAuthErrorCodes.stateNotFound,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.stateNotFound],
-    },
-    nonceMismatchError: {
-        code: ClientAuthErrorCodes.nonceMismatch,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.nonceMismatch],
-    },
-    authTimeNotFoundError: {
-        code: ClientAuthErrorCodes.authTimeNotFound,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.authTimeNotFound],
-    },
-    maxAgeTranspired: {
-        code: ClientAuthErrorCodes.maxAgeTranspired,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.maxAgeTranspired],
-    },
-    multipleMatchingTokens: {
-        code: ClientAuthErrorCodes.multipleMatchingTokens,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.multipleMatchingTokens
-        ],
-    },
-    multipleMatchingAccounts: {
-        code: ClientAuthErrorCodes.multipleMatchingAccounts,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.multipleMatchingAccounts
-        ],
-    },
-    multipleMatchingAppMetadata: {
-        code: ClientAuthErrorCodes.multipleMatchingAppMetadata,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.multipleMatchingAppMetadata
-        ],
-    },
-    tokenRequestCannotBeMade: {
-        code: ClientAuthErrorCodes.requestCannotBeMade,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.requestCannotBeMade],
-    },
-    removeEmptyScopeError: {
-        code: ClientAuthErrorCodes.cannotRemoveEmptyScope,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.cannotRemoveEmptyScope
-        ],
-    },
-    appendScopeSetError: {
-        code: ClientAuthErrorCodes.cannotAppendScopeSet,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.cannotAppendScopeSet
-        ],
-    },
-    emptyInputScopeSetError: {
-        code: ClientAuthErrorCodes.emptyInputScopeSet,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.emptyInputScopeSet],
-    },
-    DeviceCodePollingCancelled: {
-        code: ClientAuthErrorCodes.deviceCodePollingCancelled,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.deviceCodePollingCancelled
-        ],
-    },
-    DeviceCodeExpired: {
-        code: ClientAuthErrorCodes.deviceCodeExpired,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.deviceCodeExpired],
-    },
-    DeviceCodeUnknownError: {
-        code: ClientAuthErrorCodes.deviceCodeUnknownError,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.deviceCodeUnknownError
-        ],
-    },
-    NoAccountInSilentRequest: {
-        code: ClientAuthErrorCodes.noAccountInSilentRequest,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.noAccountInSilentRequest
-        ],
-    },
-    invalidCacheRecord: {
-        code: ClientAuthErrorCodes.invalidCacheRecord,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.invalidCacheRecord],
-    },
-    invalidCacheEnvironment: {
-        code: ClientAuthErrorCodes.invalidCacheEnvironment,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.invalidCacheEnvironment
-        ],
-    },
-    noAccountFound: {
-        code: ClientAuthErrorCodes.noAccountFound,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.noAccountFound],
-    },
-    noCryptoObj: {
-        code: ClientAuthErrorCodes.noCryptoObject,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.noCryptoObject],
-    },
-    unexpectedCredentialType: {
-        code: ClientAuthErrorCodes.unexpectedCredentialType,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.unexpectedCredentialType
-        ],
-    },
-    invalidAssertion: {
-        code: ClientAuthErrorCodes.invalidAssertion,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.invalidAssertion],
-    },
-    invalidClientCredential: {
-        code: ClientAuthErrorCodes.invalidClientCredential,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.invalidClientCredential
-        ],
-    },
-    tokenRefreshRequired: {
-        code: ClientAuthErrorCodes.tokenRefreshRequired,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.tokenRefreshRequired
-        ],
-    },
-    userTimeoutReached: {
-        code: ClientAuthErrorCodes.userTimeoutReached,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.userTimeoutReached],
-    },
-    tokenClaimsRequired: {
-        code: ClientAuthErrorCodes.tokenClaimsCnfRequiredForSignedJwt,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.tokenClaimsCnfRequiredForSignedJwt
-        ],
-    },
-    noAuthorizationCodeFromServer: {
-        code: ClientAuthErrorCodes.authorizationCodeMissingFromServerResponse,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.authorizationCodeMissingFromServerResponse
-        ],
-    },
-    bindingKeyNotRemovedError: {
-        code: ClientAuthErrorCodes.bindingKeyNotRemoved,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.bindingKeyNotRemoved
-        ],
-    },
-    logoutNotSupported: {
-        code: ClientAuthErrorCodes.endSessionEndpointNotSupported,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.endSessionEndpointNotSupported
-        ],
-    },
-    keyIdMissing: {
-        code: ClientAuthErrorCodes.keyIdMissing,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.keyIdMissing],
-    },
-    noNetworkConnectivity: {
-        code: ClientAuthErrorCodes.noNetworkConnectivity,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.noNetworkConnectivity
-        ],
-    },
-    userCanceledError: {
-        code: ClientAuthErrorCodes.userCanceled,
-        desc: ClientAuthErrorMessages[ClientAuthErrorCodes.userCanceled],
-    },
-    missingTenantIdError: {
-        code: ClientAuthErrorCodes.missingTenantIdError,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.missingTenantIdError
-        ],
-    },
-    nestedAppAuthBridgeDisabled: {
-        code: ClientAuthErrorCodes.nestedAppAuthBridgeDisabled,
-        desc: ClientAuthErrorMessages[
-            ClientAuthErrorCodes.nestedAppAuthBridgeDisabled
-        ],
-    },
-};
-
 /**
  * Error thrown when there is an error in the client code running on the browser.
  */
 export class ClientAuthError extends AuthError {
     constructor(errorCode: string, additionalMessage?: string) {
-        super(
-            errorCode,
-            additionalMessage
-                ? `${ClientAuthErrorMessages[errorCode]}: ${additionalMessage}`
-                : ClientAuthErrorMessages[errorCode]
-        );
+        super(errorCode, additionalMessage);
         this.name = "ClientAuthError";
 
         Object.setPrototypeOf(this, ClientAuthError.prototype);

package/src/error/ClientAuthErrorCodes.ts

@@ -18,25 +18,18 @@ export const nonceMismatch = "nonce_mismatch";
 export const authTimeNotFound = "auth_time_not_found";
 export const maxAgeTranspired = "max_age_transpired";
 export const multipleMatchingTokens = "multiple_matching_tokens";
-export const multipleMatchingAccounts = "multiple_matching_accounts";
 export const multipleMatchingAppMetadata = "multiple_matching_appMetadata";
 export const requestCannotBeMade = "request_cannot_be_made";
 export const cannotRemoveEmptyScope = "cannot_remove_empty_scope";
 export const cannotAppendScopeSet = "cannot_append_scopeset";
 export const emptyInputScopeSet = "empty_input_scopeset";
-export const deviceCodePollingCancelled = "device_code_polling_cancelled";
-export const deviceCodeExpired = "device_code_expired";
-export const deviceCodeUnknownError = "device_code_unknown_error";
 export const noAccountInSilentRequest = "no_account_in_silent_request";
 export const invalidCacheRecord = "invalid_cache_record";
 export const invalidCacheEnvironment = "invalid_cache_environment";
 export const noAccountFound = "no_account_found";
 export const noCryptoObject = "no_crypto_object";
 export const unexpectedCredentialType = "unexpected_credential_type";
-export const invalidAssertion = "invalid_assertion";
-export const invalidClientCredential = "invalid_client_credential";
 export const tokenRefreshRequired = "token_refresh_required";
-export const userTimeoutReached = "user_timeout_reached";
 export const tokenClaimsCnfRequiredForSignedJwt =
     "token_claims_cnf_required_for_signedjwt";
 export const authorizationCodeMissingFromServerResponse =
@@ -47,6 +40,5 @@ export const endSessionEndpointNotSupported =
 export const keyIdMissing = "key_id_missing";
 export const noNetworkConnectivity = "no_network_connectivity";
 export const userCanceled = "user_canceled";
-export const missingTenantIdError = "missing_tenant_id_error";
 export const methodNotImplemented = "method_not_implemented";
 export const nestedAppAuthBridgeDisabled = "nested_app_auth_bridge_disabled";

package/src/error/ClientConfigurationError.ts

@@ -7,205 +7,12 @@ import { AuthError } from "./AuthError.js";
 import * as ClientConfigurationErrorCodes from "./ClientConfigurationErrorCodes.js";
 export { ClientConfigurationErrorCodes };
 
-export const ClientConfigurationErrorMessages = {
-    [ClientConfigurationErrorCodes.redirectUriEmpty]:
-        "A redirect URI is required for all calls, and none has been set.",
-    [ClientConfigurationErrorCodes.claimsRequestParsingError]:
-        "Could not parse the given claims request object.",
-    [ClientConfigurationErrorCodes.authorityUriInsecure]:
-        "Authority URIs must use https.  Please see here for valid authority configuration options: https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-js-initializing-client-applications#configuration-options",
-    [ClientConfigurationErrorCodes.urlParseError]:
-        "URL could not be parsed into appropriate segments.",
-    [ClientConfigurationErrorCodes.urlEmptyError]: "URL was empty or null.",
-    [ClientConfigurationErrorCodes.emptyInputScopesError]:
-        "Scopes cannot be passed as null, undefined or empty array because they are required to obtain an access token.",
-    [ClientConfigurationErrorCodes.invalidClaims]:
-        "Given claims parameter must be a stringified JSON object.",
-    [ClientConfigurationErrorCodes.tokenRequestEmpty]:
-        "Token request was empty and not found in cache.",
-    [ClientConfigurationErrorCodes.logoutRequestEmpty]:
-        "The logout request was null or undefined.",
-    [ClientConfigurationErrorCodes.invalidCodeChallengeMethod]:
-        'code_challenge_method passed is invalid. Valid values are "plain" and "S256".',
-    [ClientConfigurationErrorCodes.pkceParamsMissing]:
-        "Both params: code_challenge and code_challenge_method are to be passed if to be sent in the request",
-    [ClientConfigurationErrorCodes.invalidCloudDiscoveryMetadata]:
-        "Invalid cloudDiscoveryMetadata provided. Must be a stringified JSON object containing tenant_discovery_endpoint and metadata fields",
-    [ClientConfigurationErrorCodes.invalidAuthorityMetadata]:
-        "Invalid authorityMetadata provided. Must by a stringified JSON object containing authorization_endpoint, token_endpoint, issuer fields.",
-    [ClientConfigurationErrorCodes.untrustedAuthority]:
-        "The provided authority is not a trusted authority. Please include this authority in the knownAuthorities config parameter.",
-    [ClientConfigurationErrorCodes.missingSshJwk]:
-        "Missing sshJwk in SSH certificate request. A stringified JSON Web Key is required when using the SSH authentication scheme.",
-    [ClientConfigurationErrorCodes.missingSshKid]:
-        "Missing sshKid in SSH certificate request. A string that uniquely identifies the public SSH key is required when using the SSH authentication scheme.",
-    [ClientConfigurationErrorCodes.missingNonceAuthenticationHeader]:
-        "Unable to find an authentication header containing server nonce. Either the Authentication-Info or WWW-Authenticate headers must be present in order to obtain a server nonce.",
-    [ClientConfigurationErrorCodes.invalidAuthenticationHeader]:
-        "Invalid authentication header provided",
-    [ClientConfigurationErrorCodes.cannotSetOIDCOptions]:
-        "Cannot set OIDCOptions parameter. Please change the protocol mode to OIDC or use a non-Microsoft authority.",
-    [ClientConfigurationErrorCodes.cannotAllowPlatformBroker]:
-        "Cannot set allowPlatformBroker parameter to true when not in AAD protocol mode.",
-    [ClientConfigurationErrorCodes.authorityMismatch]:
-        "Authority mismatch error. Authority provided in login request or PublicClientApplication config does not match the environment of the provided account. Please use a matching account or make an interactive request to login to this authority.",
-    [ClientConfigurationErrorCodes.invalidAuthorizePostBodyParameters]:
-        "Invalid authorize post body parameters provided. If you are using authorizePostBodyParameters, the request method must be POST. Please check the request method and parameters.",
-    [ClientConfigurationErrorCodes.invalidRequestMethodForEAR]:
-        "Invalid request method for EAR protocol mode. The request method cannot be GET when using EAR protocol mode. Please change the request method to POST.",
-};
-
-/**
- * ClientConfigurationErrorMessage class containing string constants used by error codes and messages.
- * @deprecated Use ClientConfigurationErrorCodes instead
- */
-export const ClientConfigurationErrorMessage = {
-    redirectUriNotSet: {
-        code: ClientConfigurationErrorCodes.redirectUriEmpty,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.redirectUriEmpty
-        ],
-    },
-    claimsRequestParsingError: {
-        code: ClientConfigurationErrorCodes.claimsRequestParsingError,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.claimsRequestParsingError
-        ],
-    },
-    authorityUriInsecure: {
-        code: ClientConfigurationErrorCodes.authorityUriInsecure,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.authorityUriInsecure
-        ],
-    },
-    urlParseError: {
-        code: ClientConfigurationErrorCodes.urlParseError,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.urlParseError
-        ],
-    },
-    urlEmptyError: {
-        code: ClientConfigurationErrorCodes.urlEmptyError,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.urlEmptyError
-        ],
-    },
-    emptyScopesError: {
-        code: ClientConfigurationErrorCodes.emptyInputScopesError,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.emptyInputScopesError
-        ],
-    },
-    invalidClaimsRequest: {
-        code: ClientConfigurationErrorCodes.invalidClaims,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.invalidClaims
-        ],
-    },
-    tokenRequestEmptyError: {
-        code: ClientConfigurationErrorCodes.tokenRequestEmpty,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.tokenRequestEmpty
-        ],
-    },
-    logoutRequestEmptyError: {
-        code: ClientConfigurationErrorCodes.logoutRequestEmpty,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.logoutRequestEmpty
-        ],
-    },
-    invalidCodeChallengeMethod: {
-        code: ClientConfigurationErrorCodes.invalidCodeChallengeMethod,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.invalidCodeChallengeMethod
-        ],
-    },
-    invalidCodeChallengeParams: {
-        code: ClientConfigurationErrorCodes.pkceParamsMissing,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.pkceParamsMissing
-        ],
-    },
-    invalidCloudDiscoveryMetadata: {
-        code: ClientConfigurationErrorCodes.invalidCloudDiscoveryMetadata,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.invalidCloudDiscoveryMetadata
-        ],
-    },
-    invalidAuthorityMetadata: {
-        code: ClientConfigurationErrorCodes.invalidAuthorityMetadata,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.invalidAuthorityMetadata
-        ],
-    },
-    untrustedAuthority: {
-        code: ClientConfigurationErrorCodes.untrustedAuthority,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.untrustedAuthority
-        ],
-    },
-    missingSshJwk: {
-        code: ClientConfigurationErrorCodes.missingSshJwk,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.missingSshJwk
-        ],
-    },
-    missingSshKid: {
-        code: ClientConfigurationErrorCodes.missingSshKid,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.missingSshKid
-        ],
-    },
-    missingNonceAuthenticationHeader: {
-        code: ClientConfigurationErrorCodes.missingNonceAuthenticationHeader,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.missingNonceAuthenticationHeader
-        ],
-    },
-    invalidAuthenticationHeader: {
-        code: ClientConfigurationErrorCodes.invalidAuthenticationHeader,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.invalidAuthenticationHeader
-        ],
-    },
-    cannotSetOIDCOptions: {
-        code: ClientConfigurationErrorCodes.cannotSetOIDCOptions,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.cannotSetOIDCOptions
-        ],
-    },
-    cannotAllowPlatformBroker: {
-        code: ClientConfigurationErrorCodes.cannotAllowPlatformBroker,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.cannotAllowPlatformBroker
-        ],
-    },
-    authorityMismatch: {
-        code: ClientConfigurationErrorCodes.authorityMismatch,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.authorityMismatch
-        ],
-    },
-    invalidAuthorizePostBodyParameters: {
-        code: ClientConfigurationErrorCodes.invalidAuthorizePostBodyParameters,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.invalidAuthorizePostBodyParameters
-        ],
-    },
-    invalidRequestMethodForEAR: {
-        code: ClientConfigurationErrorCodes.invalidRequestMethodForEAR,
-        desc: ClientConfigurationErrorMessages[
-            ClientConfigurationErrorCodes.invalidRequestMethodForEAR
-        ],
-    },
-};
-
 /**
  * Error thrown when there is an error in configuration of the MSAL.js library.
  */
 export class ClientConfigurationError extends AuthError {
     constructor(errorCode: string) {
-        super(errorCode, ClientConfigurationErrorMessages[errorCode]);
+        super(errorCode);
         this.name = "ClientConfigurationError";
         Object.setPrototypeOf(this, ClientConfigurationError.prototype);
     }

package/src/error/ClientConfigurationErrorCodes.ts

@@ -25,6 +25,3 @@ export const invalidAuthenticationHeader = "invalid_authentication_header";
 export const cannotSetOIDCOptions = "cannot_set_OIDCOptions";
 export const cannotAllowPlatformBroker = "cannot_allow_platform_broker";
 export const authorityMismatch = "authority_mismatch";
-export const invalidRequestMethodForEAR = "invalid_request_method_for_EAR";
-export const invalidAuthorizePostBodyParameters =
-    "invalid_authorize_post_body_parameters";