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

package/src/error/InteractionRequiredAuthError.ts

@@ -5,14 +5,16 @@
 
 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 = [
-    "interaction_required",
-    "consent_required",
-    "login_required",
+    InteractionRequiredAuthErrorCodes.interactionRequired,
+    InteractionRequiredAuthErrorCodes.consentRequired,
+    InteractionRequiredAuthErrorCodes.loginRequired,
 ];
 
 export const InteractionRequiredAuthSubErrorMessage = [
@@ -23,17 +25,29 @@ export const InteractionRequiredAuthSubErrorMessage = [
     "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: "no_tokens_found",
-        desc: "No refresh token found in the cache. Please sign-in.",
+        code: InteractionRequiredAuthErrorCodes.noTokensFound,
+        desc: InteractionRequiredAuthErrorMessages[
+            InteractionRequiredAuthErrorCodes.noTokensFound
+        ],
     },
     native_account_unavailable: {
-        code: "native_account_unavailable",
-        desc: "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.",
+        code: InteractionRequiredAuthErrorCodes.nativeAccountUnavailable,
+        desc: InteractionRequiredAuthErrorMessages[
+            InteractionRequiredAuthErrorCodes.nativeAccountUnavailable
+        ],
     },
 };
 
@@ -80,55 +94,46 @@ export class InteractionRequiredAuthError extends AuthError {
         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
-     */
-    static 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
-        );
-    }
+/**
+ * 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;
+        });
 
-    /**
-     * Creates an error thrown when the authorization code required for a token request is null or empty.
-     */
-    static createNoTokensFoundError(): InteractionRequiredAuthError {
-        return new InteractionRequiredAuthError(
-            InteractionRequiredAuthErrorMessage.noTokensFoundError.code,
-            InteractionRequiredAuthErrorMessage.noTokensFoundError.desc
-        );
-    }
+    return (
+        isInteractionRequiredErrorCode ||
+        isInteractionRequiredErrorDesc ||
+        isInteractionRequiredSubError
+    );
+}
 
-    /**
-     * Creates an error thrown when the native broker returns ACCOUNT_UNAVAILABLE status, indicating that the account was removed and interactive sign-in is required
-     * @returns
-     */
-    static createNativeAccountUnavailableError(): InteractionRequiredAuthError {
-        return new InteractionRequiredAuthError(
-            InteractionRequiredAuthErrorMessage.native_account_unavailable.code,
-            InteractionRequiredAuthErrorMessage.native_account_unavailable.desc
-        );
-    }
+/**
+ * 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

@@ -4,19 +4,14 @@
  */
 
 import { AuthError } from "./AuthError";
+import * as JoseHeaderErrorCodes from "./JoseHeaderErrorCodes";
+export { JoseHeaderErrorCodes };
 
-/**
- * ClientAuthErrorMessage class containing string constants used by error codes and messages.
- */
-export const JoseHeaderErrorMessage = {
-    missingKidError: {
-        code: "missing_kid_error",
-        desc: "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.",
-    },
-    missingAlgError: {
-        code: "missing_alg_error",
-        desc: "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.",
-    },
+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.",
 };
 
 /**
@@ -29,24 +24,9 @@ export class JoseHeaderError extends AuthError {
 
         Object.setPrototypeOf(this, JoseHeaderError.prototype);
     }
+}
 
-    /**
-     * Creates an error thrown when keyId isn't set on JOSE header.
-     */
-    static createMissingKidError(): JoseHeaderError {
-        return new JoseHeaderError(
-            JoseHeaderErrorMessage.missingKidError.code,
-            JoseHeaderErrorMessage.missingKidError.desc
-        );
-    }
-
-    /**
-     * Creates an error thrown when algorithm isn't set on JOSE header.
-     */
-    static createMissingAlgError(): JoseHeaderError {
-        return new JoseHeaderError(
-            JoseHeaderErrorMessage.missingAlgError.code,
-            JoseHeaderErrorMessage.missingAlgError.desc
-        );
-    }
+/** 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/index.ts

@@ -137,17 +137,28 @@ export { ILoggerCallback, LogLevel, Logger } from "./logger/Logger";
 // Errors
 export {
     InteractionRequiredAuthError,
+    InteractionRequiredAuthErrorCodes,
     InteractionRequiredAuthErrorMessage,
+    createInteractionRequiredAuthError,
 } from "./error/InteractionRequiredAuthError";
-export { AuthError, AuthErrorMessage } from "./error/AuthError";
+export {
+    AuthError,
+    AuthErrorMessage,
+    AuthErrorCodes,
+    createAuthError,
+} from "./error/AuthError";
 export { ServerError } from "./error/ServerError";
 export {
     ClientAuthError,
     ClientAuthErrorMessage,
+    ClientAuthErrorCodes,
+    createClientAuthError,
 } from "./error/ClientAuthError";
 export {
     ClientConfigurationError,
     ClientConfigurationErrorMessage,
+    ClientConfigurationErrorCodes,
+    createClientConfigurationError,
 } from "./error/ClientConfigurationError";
 // Constants and Utils
 export {

package/src/network/INetworkModule.ts

@@ -3,7 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { AuthError } from "../error/AuthError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 import { NetworkResponse } from "./NetworkManager";
 
 /**
@@ -45,13 +48,13 @@ export interface INetworkModule {
 
 export const StubbedNetworkModule: INetworkModule = {
     sendGetRequestAsync: () => {
-        const notImplErr =
-            "Network interface - sendGetRequestAsync() has not been implemented for the Network interface.";
-        return Promise.reject(AuthError.createUnexpectedError(notImplErr));
+        return Promise.reject(
+            createClientAuthError(ClientAuthErrorCodes.methodNotImplemented)
+        );
     },
     sendPostRequestAsync: () => {
-        const notImplErr =
-            "Network interface - sendPostRequestAsync() has not been implemented for the Network interface.";
-        return Promise.reject(AuthError.createUnexpectedError(notImplErr));
+        return Promise.reject(
+            createClientAuthError(ClientAuthErrorCodes.methodNotImplemented)
+        );
     },
 };

package/src/network/NetworkManager.ts

@@ -8,7 +8,10 @@ import { RequestThumbprint } from "./RequestThumbprint";
 import { ThrottlingUtils } from "./ThrottlingUtils";
 import { CacheManager } from "../cache/CacheManager";
 import { AuthError } from "../error/AuthError";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 import { ServerAuthorizationTokenResponse } from "../response/ServerAuthorizationTokenResponse";
 
 export type NetworkResponse<T> = {
@@ -62,10 +65,7 @@ export class NetworkManager {
             if (e instanceof AuthError) {
                 throw e;
             } else {
-                throw ClientAuthError.createNetworkError(
-                    tokenEndpoint,
-                    e as string
-                );
+                throw createClientAuthError(ClientAuthErrorCodes.networkError);
             }
         }
 

package/src/request/AuthenticationHeaderParser.ts

@@ -3,7 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { ClientConfigurationError } from "../error/ClientConfigurationError";
+import {
+    createClientConfigurationError,
+    ClientConfigurationErrorCodes,
+} from "../error/ClientConfigurationError";
 import { Constants, HeaderNames } from "../utils/Constants";
 
 type WWWAuthenticateChallenges = {
@@ -40,9 +43,8 @@ export class AuthenticationHeaderParser {
             if (authenticationInfoChallenges.nextnonce) {
                 return authenticationInfoChallenges.nextnonce;
             }
-            throw ClientConfigurationError.createInvalidAuthenticationHeaderError(
-                HeaderNames.AuthenticationInfo,
-                "nextnonce challenge is missing."
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.invalidAuthenticationHeader
             );
         }
 
@@ -56,14 +58,15 @@ export class AuthenticationHeaderParser {
             if (wwwAuthenticateChallenges.nonce) {
                 return wwwAuthenticateChallenges.nonce;
             }
-            throw ClientConfigurationError.createInvalidAuthenticationHeaderError(
-                HeaderNames.WWWAuthenticate,
-                "nonce challenge is missing."
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.invalidAuthenticationHeader
             );
         }
 
         // If neither header is present, throw missing headers error
-        throw ClientConfigurationError.createMissingNonceAuthenticationHeadersError();
+        throw createClientConfigurationError(
+            ClientConfigurationErrorCodes.missingNonceAuthenticationHeader
+        );
     }
 
     /**

package/src/request/RequestParameterBuilder.ts

@@ -17,7 +17,10 @@ import {
     HeaderNames,
 } from "../utils/Constants";
 import { ScopeSet } from "./ScopeSet";
-import { ClientConfigurationError } from "../error/ClientConfigurationError";
+import {
+    createClientConfigurationError,
+    ClientConfigurationErrorCodes,
+} from "../error/ClientConfigurationError";
 import { StringDict } from "../utils/MsalTypes";
 import { RequestValidator } from "./RequestValidator";
 import {
@@ -330,7 +333,9 @@ export class RequestParameterBuilder {
                 encodeURIComponent(codeChallengeMethod)
             );
         } else {
-            throw ClientConfigurationError.createInvalidCodeChallengeParamsError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.pkceParamsMissing
+            );
         }
     }
 
@@ -480,7 +485,9 @@ export class RequestParameterBuilder {
             try {
                 mergedClaims = JSON.parse(claims);
             } catch (e) {
-                throw ClientConfigurationError.createInvalidClaimsRequestError();
+                throw createClientConfigurationError(
+                    ClientConfigurationErrorCodes.invalidClaims
+                );
             }
         }
 

package/src/request/RequestValidator.ts

@@ -3,7 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { ClientConfigurationError } from "../error/ClientConfigurationError";
+import {
+    createClientConfigurationError,
+    ClientConfigurationErrorCodes,
+} from "../error/ClientConfigurationError";
 import { PromptValue, CodeChallengeMethodValues } from "../utils/Constants";
 import { StringDict } from "../utils/MsalTypes";
 
@@ -17,7 +20,9 @@ export class RequestValidator {
      */
     static validateRedirectUri(redirectUri: string): void {
         if (!redirectUri) {
-            throw ClientConfigurationError.createRedirectUriEmptyError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.redirectUriEmpty
+            );
         }
     }
 
@@ -33,7 +38,9 @@ export class RequestValidator {
         }
 
         if (promptValues.indexOf(prompt) < 0) {
-            throw ClientConfigurationError.createInvalidPromptError(prompt);
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.invalidPromptValue
+            );
         }
     }
 
@@ -41,7 +48,9 @@ export class RequestValidator {
         try {
             JSON.parse(claims);
         } catch (e) {
-            throw ClientConfigurationError.createInvalidClaimsRequestError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.invalidClaims
+            );
         }
     }
 
@@ -55,7 +64,9 @@ export class RequestValidator {
         codeChallengeMethod: string
     ): void {
         if (!codeChallenge || !codeChallengeMethod) {
-            throw ClientConfigurationError.createInvalidCodeChallengeParamsError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.pkceParamsMissing
+            );
         } else {
             this.validateCodeChallengeMethod(codeChallengeMethod);
         }
@@ -72,7 +83,9 @@ export class RequestValidator {
                 CodeChallengeMethodValues.S256,
             ].indexOf(codeChallengeMethod) < 0
         ) {
-            throw ClientConfigurationError.createInvalidCodeChallengeMethodError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.invalidCodeChallengeMethod
+            );
         }
     }
 

package/src/request/ScopeSet.ts

@@ -3,9 +3,15 @@
  * Licensed under the MIT License.
  */
 
-import { ClientConfigurationError } from "../error/ClientConfigurationError";
+import {
+    createClientConfigurationError,
+    ClientConfigurationErrorCodes,
+} from "../error/ClientConfigurationError";
 import { StringUtils } from "../utils/StringUtils";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 import { Constants, OIDC_SCOPES } from "../utils/Constants";
 
 /**
@@ -69,7 +75,9 @@ export class ScopeSet {
     private validateInputScopes(inputScopes: Array<string>): void {
         // Check if scopes are required but not given or is an empty array
         if (!inputScopes || inputScopes.length < 1) {
-            throw ClientConfigurationError.createEmptyScopesArrayError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.emptyInputScopesError
+            );
         }
     }
 
@@ -133,7 +141,9 @@ export class ScopeSet {
         try {
             newScopes.forEach((newScope) => this.appendScope(newScope));
         } catch (e) {
-            throw ClientAuthError.createAppendScopeSetError(e as string);
+            throw createClientAuthError(
+                ClientAuthErrorCodes.cannotAppendScopeSet
+            );
         }
     }
 
@@ -143,7 +153,9 @@ export class ScopeSet {
      */
     removeScope(scope: string): void {
         if (!scope) {
-            throw ClientAuthError.createRemoveEmptyScopeFromSetError(scope);
+            throw createClientAuthError(
+                ClientAuthErrorCodes.cannotRemoveEmptyScope
+            );
         }
         this.scopes.delete(scope.trim());
     }
@@ -164,7 +176,9 @@ export class ScopeSet {
      */
     unionScopeSets(otherScopes: ScopeSet): Set<string> {
         if (!otherScopes) {
-            throw ClientAuthError.createEmptyInputScopeSetError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.emptyInputScopeSet
+            );
         }
         const unionScopes = new Set<string>(); // Iterator in constructor not supported in IE11
         otherScopes.scopes.forEach((scope) =>
@@ -180,7 +194,9 @@ export class ScopeSet {
      */
     intersectingScopeSets(otherScopes: ScopeSet): boolean {
         if (!otherScopes) {
-            throw ClientAuthError.createEmptyInputScopeSetError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.emptyInputScopeSet
+            );
         }
 
         // Do not allow OIDC scopes to be the only intersecting scopes

package/src/response/ResponseHandler.ts

@@ -6,7 +6,10 @@
 import { ServerAuthorizationTokenResponse } from "./ServerAuthorizationTokenResponse";
 import { buildClientInfo } from "../account/ClientInfo";
 import { ICrypto } from "../crypto/ICrypto";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 import { ServerAuthorizationCodeResponse } from "./ServerAuthorizationCodeResponse";
 import { Logger } from "../logger/Logger";
 import { ServerError } from "../error/ServerError";
@@ -17,7 +20,10 @@ import { Authority } from "../authority/Authority";
 import { IdTokenEntity } from "../cache/entities/IdTokenEntity";
 import { AccessTokenEntity } from "../cache/entities/AccessTokenEntity";
 import { RefreshTokenEntity } from "../cache/entities/RefreshTokenEntity";
-import { InteractionRequiredAuthError } from "../error/InteractionRequiredAuthError";
+import {
+    InteractionRequiredAuthError,
+    isInteractionRequiredError,
+} from "../error/InteractionRequiredAuthError";
 import { CacheRecord } from "../cache/entities/CacheRecord";
 import { CacheManager } from "../cache/CacheManager";
 import { ProtocolUtils, RequestStateObject } from "../utils/ProtocolUtils";
@@ -84,8 +90,14 @@ export class ResponseHandler {
     ): void {
         if (!serverResponseHash.state || !cachedState) {
             throw serverResponseHash.state
-                ? ClientAuthError.createStateNotFoundError("Cached State")
-                : ClientAuthError.createStateNotFoundError("Server State");
+                ? createClientAuthError(
+                      ClientAuthErrorCodes.stateNotFound,
+                      "Cached State"
+                  )
+                : createClientAuthError(
+                      ClientAuthErrorCodes.stateNotFound,
+                      "Server State"
+                  );
         }
 
         let decodedServerResponseHash: string;
@@ -96,23 +108,23 @@ export class ResponseHandler {
                 serverResponseHash.state
             );
         } catch (e) {
-            throw ClientAuthError.createInvalidStateError(
-                serverResponseHash.state,
-                `Server response hash URI could not be decoded`
+            throw createClientAuthError(
+                ClientAuthErrorCodes.invalidState,
+                serverResponseHash.state
             );
         }
 
         try {
             decodedCachedState = decodeURIComponent(cachedState);
         } catch (e) {
-            throw ClientAuthError.createInvalidStateError(
-                serverResponseHash.state,
-                `Cached state URI could not be decoded`
+            throw createClientAuthError(
+                ClientAuthErrorCodes.invalidState,
+                serverResponseHash.state
             );
         }
 
         if (decodedServerResponseHash !== decodedCachedState) {
-            throw ClientAuthError.createStateMismatchError();
+            throw createClientAuthError(ClientAuthErrorCodes.stateMismatch);
         }
 
         // Check for error
@@ -122,7 +134,7 @@ export class ResponseHandler {
             serverResponseHash.suberror
         ) {
             if (
-                InteractionRequiredAuthError.isInteractionRequiredError(
+                isInteractionRequiredError(
                     serverResponseHash.error,
                     serverResponseHash.error_description,
                     serverResponseHash.suberror
@@ -202,7 +214,7 @@ export class ResponseHandler {
             }
 
             if (
-                InteractionRequiredAuthError.isInteractionRequiredError(
+                isInteractionRequiredError(
                     serverResponse.error,
                     serverResponse.error_description,
                     serverResponse.suberror
@@ -255,7 +267,9 @@ export class ResponseHandler {
             // token nonce check (TODO: Add a warning if no nonce is given?)
             if (authCodePayload && authCodePayload.nonce) {
                 if (idTokenClaims.nonce !== authCodePayload.nonce) {
-                    throw ClientAuthError.createNonceMismatchError();
+                    throw createClientAuthError(
+                        ClientAuthErrorCodes.nonceMismatch
+                    );
                 }
             }
 
@@ -263,7 +277,9 @@ export class ResponseHandler {
             if (request.maxAge || request.maxAge === 0) {
                 const authTime = idTokenClaims.auth_time;
                 if (!authTime) {
-                    throw ClientAuthError.createAuthTimeNotFoundError();
+                    throw createClientAuthError(
+                        ClientAuthErrorCodes.authTimeNotFound
+                    );
                 }
 
                 checkMaxAge(authTime, request.maxAge);
@@ -389,7 +405,9 @@ export class ResponseHandler {
     ): CacheRecord {
         const env = authority.getPreferredCache();
         if (!env) {
-            throw ClientAuthError.createInvalidCacheEnvironmentError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.invalidCacheEnvironment
+            );
         }
 
         // IdToken: non AAD scenarios can have empty realm
@@ -537,7 +555,9 @@ export class ResponseHandler {
                 const { secret, keyId } = cacheRecord.accessToken;
 
                 if (!keyId) {
-                    throw ClientAuthError.createKeyIdMissingError();
+                    throw createClientAuthError(
+                        ClientAuthErrorCodes.keyIdMissing
+                    );
                 }
 
                 accessToken = await popTokenGenerator.signPopToken(