@azure/msal-common 14.0.2 → 14.1.0-alpha.0

package/src/error/ClientAuthErrorCodes.ts

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export const clientInfoDecodingError = "client_info_decoding_error";
+export const clientInfoEmptyError = "client_info_empty_error";
+export const tokenParsingError = "token_parsing_error";
+export const nullOrEmptyToken = "null_or_empty_token";
+export const endpointResolutionError = "endpoints_resolution_error";
+export const networkError = "network_error";
+export const openIdConfigError = "openid_config_error";
+export const hashNotDeserialized = "hash_not_deserialized";
+export const invalidState = "invalid_state";
+export const stateMismatch = "state_mismatch";
+export const stateNotFound = "state_not_found";
+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 =
+    "authorization_code_missing_from_server_response";
+export const bindingKeyNotRemoved = "binding_key_not_removed";
+export const endSessionEndpointNotSupported =
+    "end_session_endpoint_not_supported";
+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";

package/src/error/ClientConfigurationError.ts

@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthError } from "./AuthError";
+import * as ClientConfigurationErrorCodes from "./ClientConfigurationErrorCodes";
+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.invalidPromptValue]:
+        "Please see here for valid configuration options: https://azuread.github.io/microsoft-authentication-library-for-js/ref/modules/_azure_msal_common.html#commonauthorizationurlrequest",
+    [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.cannotAllowNativeBroker]:
+        "Cannot set allowNativeBroker 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.",
+};
+
+/**
+ * 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
+        ],
+    },
+    invalidPrompt: {
+        code: ClientConfigurationErrorCodes.invalidPromptValue,
+        desc: ClientConfigurationErrorMessages[
+            ClientConfigurationErrorCodes.invalidPromptValue
+        ],
+    },
+    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
+        ],
+    },
+    cannotAllowNativeBroker: {
+        code: ClientConfigurationErrorCodes.cannotAllowNativeBroker,
+        desc: ClientConfigurationErrorMessages[
+            ClientConfigurationErrorCodes.cannotAllowNativeBroker
+        ],
+    },
+    authorityMismatch: {
+        code: ClientConfigurationErrorCodes.authorityMismatch,
+        desc: ClientConfigurationErrorMessages[
+            ClientConfigurationErrorCodes.authorityMismatch
+        ],
+    },
+};
+
+/**
+ * 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]);
+        this.name = "ClientConfigurationError";
+        Object.setPrototypeOf(this, ClientConfigurationError.prototype);
+    }
+}
+
+export function createClientConfigurationError(
+    errorCode: string
+): ClientConfigurationError {
+    return new ClientConfigurationError(errorCode);
+}

package/src/error/ClientConfigurationErrorCodes.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export const redirectUriEmpty = "redirect_uri_empty";
+export const claimsRequestParsingError = "claims_request_parsing_error";
+export const authorityUriInsecure = "authority_uri_insecure";
+export const urlParseError = "url_parse_error";
+export const urlEmptyError = "empty_url_error";
+export const emptyInputScopesError = "empty_input_scopes_error";
+export const invalidPromptValue = "invalid_prompt_value";
+export const invalidClaims = "invalid_claims";
+export const tokenRequestEmpty = "token_request_empty";
+export const logoutRequestEmpty = "logout_request_empty";
+export const invalidCodeChallengeMethod = "invalid_code_challenge_method";
+export const pkceParamsMissing = "pkce_params_missing";
+export const invalidCloudDiscoveryMetadata = "invalid_cloud_discovery_metadata";
+export const invalidAuthorityMetadata = "invalid_authority_metadata";
+export const untrustedAuthority = "untrusted_authority";
+export const missingSshJwk = "missing_ssh_jwk";
+export const missingSshKid = "missing_ssh_kid";
+export const missingNonceAuthenticationHeader =
+    "missing_nonce_authentication_header";
+export const invalidAuthenticationHeader = "invalid_authentication_header";
+export const cannotSetOIDCOptions = "cannot_set_OIDCOptions";
+export const cannotAllowNativeBroker = "cannot_allow_native_broker";
+export const authorityMismatch = "authority_mismatch";

package/src/error/InteractionRequiredAuthError.ts

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Constants } from "../utils/Constants";
+import { AuthError } from "./AuthError";
+import * as InteractionRequiredAuthErrorCodes from "./InteractionRequiredAuthErrorCodes";
+export { InteractionRequiredAuthErrorCodes };
+
+/**
+ * InteractionRequiredServerErrorMessage contains string constants used by error codes and messages returned by the server indicating interaction is required
+ */
+export const InteractionRequiredServerErrorMessage = [
+    InteractionRequiredAuthErrorCodes.interactionRequired,
+    InteractionRequiredAuthErrorCodes.consentRequired,
+    InteractionRequiredAuthErrorCodes.loginRequired,
+];
+
+export const InteractionRequiredAuthSubErrorMessage = [
+    "message_only",
+    "additional_action",
+    "basic_action",
+    "user_password_expired",
+    "consent_required",
+];
+
+const InteractionRequiredAuthErrorMessages = {
+    [InteractionRequiredAuthErrorCodes.noTokensFound]:
+        "No refresh token found in the cache. Please sign-in.",
+    [InteractionRequiredAuthErrorCodes.nativeAccountUnavailable]:
+        "The requested account is not available in the native broker. It may have been deleted or logged out. Please sign-in again using an interactive API.",
+};
+
+/**
+ * Interaction required errors defined by the SDK
+ * @deprecated Use InteractionRequiredAuthErrorCodes instead
+ */
+export const InteractionRequiredAuthErrorMessage = {
+    noTokensFoundError: {
+        code: InteractionRequiredAuthErrorCodes.noTokensFound,
+        desc: InteractionRequiredAuthErrorMessages[
+            InteractionRequiredAuthErrorCodes.noTokensFound
+        ],
+    },
+    native_account_unavailable: {
+        code: InteractionRequiredAuthErrorCodes.nativeAccountUnavailable,
+        desc: InteractionRequiredAuthErrorMessages[
+            InteractionRequiredAuthErrorCodes.nativeAccountUnavailable
+        ],
+    },
+};
+
+/**
+ * Error thrown when user interaction is required.
+ */
+export class InteractionRequiredAuthError extends AuthError {
+    /**
+     * The time the error occured at
+     */
+    timestamp: string;
+
+    /**
+     * TraceId associated with the error
+     */
+    traceId: string;
+
+    /**
+     * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-common/docs/claims-challenge.md
+     *
+     * A string with extra claims needed for the token request to succeed
+     * web site: redirect the user to the authorization page and set the extra claims
+     * web api: include the claims in the WWW-Authenticate header that are sent back to the client so that it knows to request a token with the extra claims
+     * desktop application or browser context: include the claims when acquiring the token interactively
+     * app to app context (client_credentials): include the claims in the AcquireTokenByClientCredential request
+     */
+    claims: string;
+
+    constructor(
+        errorCode?: string,
+        errorMessage?: string,
+        subError?: string,
+        timestamp?: string,
+        traceId?: string,
+        correlationId?: string,
+        claims?: string
+    ) {
+        super(errorCode, errorMessage, subError);
+        Object.setPrototypeOf(this, InteractionRequiredAuthError.prototype);
+
+        this.timestamp = timestamp || Constants.EMPTY_STRING;
+        this.traceId = traceId || Constants.EMPTY_STRING;
+        this.correlationId = correlationId || Constants.EMPTY_STRING;
+        this.claims = claims || Constants.EMPTY_STRING;
+        this.name = "InteractionRequiredAuthError";
+    }
+}
+
+/**
+ * Helper function used to determine if an error thrown by the server requires interaction to resolve
+ * @param errorCode
+ * @param errorString
+ * @param subError
+ */
+export function isInteractionRequiredError(
+    errorCode?: string,
+    errorString?: string,
+    subError?: string
+): boolean {
+    const isInteractionRequiredErrorCode =
+        !!errorCode &&
+        InteractionRequiredServerErrorMessage.indexOf(errorCode) > -1;
+    const isInteractionRequiredSubError =
+        !!subError &&
+        InteractionRequiredAuthSubErrorMessage.indexOf(subError) > -1;
+    const isInteractionRequiredErrorDesc =
+        !!errorString &&
+        InteractionRequiredServerErrorMessage.some((irErrorCode) => {
+            return errorString.indexOf(irErrorCode) > -1;
+        });
+
+    return (
+        isInteractionRequiredErrorCode ||
+        isInteractionRequiredErrorDesc ||
+        isInteractionRequiredSubError
+    );
+}
+
+/**
+ * Creates an InteractionRequiredAuthError
+ */
+export function createInteractionRequiredAuthError(
+    errorCode: string
+): InteractionRequiredAuthError {
+    return new InteractionRequiredAuthError(
+        errorCode,
+        InteractionRequiredAuthErrorMessages[errorCode]
+    );
+}

package/src/error/InteractionRequiredAuthErrorCodes.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// Codes defined by MSAL
+export const noTokensFound = "no_tokens_found";
+export const nativeAccountUnavailable = "native_account_unavailable";
+
+// Codes potentially returned by server
+export const interactionRequired = "interaction_required";
+export const consentRequired = "consent_required";
+export const loginRequired = "login_required";

package/src/error/JoseHeaderError.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthError } from "./AuthError";
+import * as JoseHeaderErrorCodes from "./JoseHeaderErrorCodes";
+export { JoseHeaderErrorCodes };
+
+export const JoseHeaderErrorMessages = {
+    [JoseHeaderErrorCodes.missingKidError]:
+        "The JOSE Header for the requested JWT, JWS or JWK object requires a keyId to be configured as the 'kid' header claim. No 'kid' value was provided.",
+    [JoseHeaderErrorCodes.missingAlgError]:
+        "The JOSE Header for the requested JWT, JWS or JWK object requires an algorithm to be specified as the 'alg' header claim. No 'alg' value was provided.",
+};
+
+/**
+ * Error thrown when there is an error in the client code running on the browser.
+ */
+export class JoseHeaderError extends AuthError {
+    constructor(errorCode: string, errorMessage?: string) {
+        super(errorCode, errorMessage);
+        this.name = "JoseHeaderError";
+
+        Object.setPrototypeOf(this, JoseHeaderError.prototype);
+    }
+}
+
+/** Returns JoseHeaderError object */
+export function createJoseHeaderError(code: string): JoseHeaderError {
+    return new JoseHeaderError(code, JoseHeaderErrorMessages[code]);
+}

package/src/error/JoseHeaderErrorCodes.ts

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export const missingKidError = "missing_kid_error";
+export const missingAlgError = "missing_alg_error";

package/src/error/ServerError.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthError } from "./AuthError";
+
+/**
+ * Error thrown when there is an error with the server code, for example, unavailability.
+ */
+export class ServerError extends AuthError {
+    constructor(errorCode?: string, errorMessage?: string, subError?: string) {
+        super(errorCode, errorMessage, subError);
+        this.name = "ServerError";
+
+        Object.setPrototypeOf(this, ServerError.prototype);
+    }
+}