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

package/src/client/RefreshTokenClient.ts

@@ -25,8 +25,14 @@ import { StringUtils } from "../utils/StringUtils";
 import { RequestThumbprint } from "../network/RequestThumbprint";
 import { NetworkResponse } from "../network/NetworkManager";
 import { CommonSilentFlowRequest } from "../request/CommonSilentFlowRequest";
-import { ClientConfigurationError } from "../error/ClientConfigurationError";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    createClientConfigurationError,
+    ClientConfigurationErrorCodes,
+} from "../error/ClientConfigurationError";
+import {
+    createClientAuthError,
+    ClientAuthErrorCodes,
+} from "../error/ClientAuthError";
 import { ServerError } from "../error/ServerError";
 import { TimeUtils } from "../utils/TimeUtils";
 import { UrlString } from "../url/UrlString";
@@ -34,10 +40,12 @@ import { CcsCredentialType } from "../account/CcsCredential";
 import { buildClientInfoFromHomeAccountId } from "../account/ClientInfo";
 import {
     InteractionRequiredAuthError,
-    InteractionRequiredAuthErrorMessage,
+    InteractionRequiredAuthErrorCodes,
+    createInteractionRequiredAuthError,
 } from "../error/InteractionRequiredAuthError";
 import { PerformanceEvents } from "../telemetry/performance/PerformanceEvent";
 import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient";
+import { invokeAsync } from "../utils/FunctionWrappers";
 /**
  * OAuth2.0 refresh token client
  * @internal
@@ -57,23 +65,14 @@ export class RefreshTokenClient extends BaseClient {
             request.correlationId
         );
 
-        const atsMeasurement = this.performanceClient?.startMeasurement(
-            PerformanceEvents.RefreshTokenClientAcquireToken,
-            request.correlationId
-        );
-        this.logger.verbose(
-            "RefreshTokenClientAcquireToken called",
-            request.correlationId
-        );
         const reqTimestamp = TimeUtils.nowSeconds();
-        this.performanceClient?.setPreQueueTime(
+        const response = await invokeAsync(
+            this.executeTokenRequest.bind(this),
             PerformanceEvents.RefreshTokenClientExecuteTokenRequest,
+            this.logger,
+            this.performanceClient,
             request.correlationId
-        );
-        const response = await this.executeTokenRequest(
-            request,
-            this.authority
-        );
+        )(request, this.authority);
 
         // Retrieve requestId from response headers
         const requestId = response.headers?.[HeaderNames.X_MS_REQUEST_ID];
@@ -87,40 +86,23 @@ export class RefreshTokenClient extends BaseClient {
         );
         responseHandler.validateTokenResponse(response.body);
 
-        this.performanceClient?.setPreQueueTime(
+        return invokeAsync(
+            responseHandler.handleServerTokenResponse.bind(responseHandler),
             PerformanceEvents.HandleServerTokenResponse,
+            this.logger,
+            this.performanceClient,
             request.correlationId
+        )(
+            response.body,
+            this.authority,
+            reqTimestamp,
+            request,
+            undefined,
+            undefined,
+            true,
+            request.forceCache,
+            requestId
         );
-        return responseHandler
-            .handleServerTokenResponse(
-                response.body,
-                this.authority,
-                reqTimestamp,
-                request,
-                undefined,
-                undefined,
-                true,
-                request.forceCache,
-                requestId
-            )
-            .then((result: AuthenticationResult) => {
-                atsMeasurement?.end({
-                    success: true,
-                });
-                return result;
-            })
-            .catch((error) => {
-                this.logger.verbose(
-                    "Error in fetching refresh token",
-                    request.correlationId
-                );
-                atsMeasurement?.end({
-                    errorCode: error.errorCode,
-                    subErrorCode: error.subError,
-                    success: false,
-                });
-                throw error;
-            });
     }
 
     /**
@@ -132,7 +114,9 @@ export class RefreshTokenClient extends BaseClient {
     ): Promise<AuthenticationResult> {
         // Cannot renew token if no request object is given.
         if (!request) {
-            throw ClientConfigurationError.createEmptyTokenRequestError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.tokenRequestEmpty
+            );
         }
 
         this.performanceClient?.addQueueMeasurement(
@@ -142,7 +126,9 @@ export class RefreshTokenClient extends BaseClient {
 
         // We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases
         if (!request.account) {
-            throw ClientAuthError.createNoAccountInSilentRequestError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.noAccountInSilentRequest
+            );
         }
 
         // try checking if FOCI is enabled for the given application
@@ -153,17 +139,18 @@ export class RefreshTokenClient extends BaseClient {
         // if the app is part of the family, retrive a Family refresh token if present and make a refreshTokenRequest
         if (isFOCI) {
             try {
-                this.performanceClient?.setPreQueueTime(
+                return invokeAsync(
+                    this.acquireTokenWithCachedRefreshToken.bind(this),
                     PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken,
+                    this.logger,
+                    this.performanceClient,
                     request.correlationId
-                );
-                return this.acquireTokenWithCachedRefreshToken(request, true);
+                )(request, true);
             } catch (e) {
                 const noFamilyRTInCache =
                     e instanceof InteractionRequiredAuthError &&
                     e.errorCode ===
-                        InteractionRequiredAuthErrorMessage.noTokensFoundError
-                            .code;
+                        InteractionRequiredAuthErrorCodes.noTokensFound;
                 const clientMismatchErrorWithFamilyRT =
                     e instanceof ServerError &&
                     e.errorCode === Errors.INVALID_GRANT_ERROR &&
@@ -171,14 +158,13 @@ export class RefreshTokenClient extends BaseClient {
 
                 // if family Refresh Token (FRT) cache acquisition fails or if client_mismatch error is seen with FRT, reattempt with application Refresh Token (ART)
                 if (noFamilyRTInCache || clientMismatchErrorWithFamilyRT) {
-                    this.performanceClient?.setPreQueueTime(
+                    return invokeAsync(
+                        this.acquireTokenWithCachedRefreshToken.bind(this),
                         PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken,
+                        this.logger,
+                        this.performanceClient,
                         request.correlationId
-                    );
-                    return this.acquireTokenWithCachedRefreshToken(
-                        request,
-                        false
-                    );
+                    )(request, false);
                     // throw in all other cases
                 } else {
                     throw e;
@@ -186,11 +172,13 @@ export class RefreshTokenClient extends BaseClient {
             }
         }
         // fall back to application refresh token acquisition
-        this.performanceClient?.setPreQueueTime(
+        return invokeAsync(
+            this.acquireTokenWithCachedRefreshToken.bind(this),
             PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken,
+            this.logger,
+            this.performanceClient,
             request.correlationId
-        );
-        return this.acquireTokenWithCachedRefreshToken(request, false);
+        )(request, false);
     }
 
     /**
@@ -207,28 +195,17 @@ export class RefreshTokenClient extends BaseClient {
         );
 
         // fetches family RT or application RT based on FOCI value
-
-        const atsMeasurement = this.performanceClient?.startMeasurement(
-            PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken,
-            request.correlationId
-        );
-        this.logger.verbose(
-            "RefreshTokenClientAcquireTokenWithCachedRefreshToken called",
-            request.correlationId
-        );
         const refreshToken = this.cacheManager.getRefreshToken(
             request.account,
             foci
         );
 
         if (!refreshToken) {
-            atsMeasurement?.discard();
-            throw InteractionRequiredAuthError.createNoTokensFoundError();
+            throw createInteractionRequiredAuthError(
+                InteractionRequiredAuthErrorCodes.noTokensFound
+            );
         }
         // attach cached RT size to the current measurement
-        atsMeasurement?.end({
-            success: true,
-        });
 
         const refreshTokenRequest: CommonRefreshTokenRequest = {
             ...request,
@@ -241,11 +218,13 @@ export class RefreshTokenClient extends BaseClient {
             },
         };
 
-        this.performanceClient?.setPreQueueTime(
+        return invokeAsync(
+            this.acquireToken.bind(this),
             PerformanceEvents.RefreshTokenClientAcquireToken,
+            this.logger,
+            this.performanceClient,
             request.correlationId
-        );
-        return this.acquireToken(refreshTokenRequest);
+        )(refreshTokenRequest);
     }
 
     /**
@@ -261,15 +240,6 @@ export class RefreshTokenClient extends BaseClient {
             PerformanceEvents.RefreshTokenClientExecuteTokenRequest,
             request.correlationId
         );
-        const acquireTokenMeasurement =
-            this.performanceClient?.startMeasurement(
-                PerformanceEvents.RefreshTokenClientExecuteTokenRequest,
-                request.correlationId
-            );
-        this.performanceClient?.setPreQueueTime(
-            PerformanceEvents.RefreshTokenClientCreateTokenRequestBody,
-            request.correlationId
-        );
 
         const queryParametersString = this.createTokenQueryParameters(request);
         const endpoint = UrlString.appendQueryString(
@@ -277,7 +247,13 @@ export class RefreshTokenClient extends BaseClient {
             queryParametersString
         );
 
-        const requestBody = await this.createTokenRequestBody(request);
+        const requestBody = await invokeAsync(
+            this.createTokenRequestBody.bind(this),
+            PerformanceEvents.RefreshTokenClientCreateTokenRequestBody,
+            this.logger,
+            this.performanceClient,
+            request.correlationId
+        )(request);
         const headers: Record<string, string> = this.createTokenRequestHeaders(
             request.ccsCredential
         );
@@ -293,25 +269,13 @@ export class RefreshTokenClient extends BaseClient {
             sshKid: request.sshKid,
         };
 
-        return this.executePostToTokenEndpoint(
-            endpoint,
-            requestBody,
-            headers,
-            thumbprint,
+        return invokeAsync(
+            this.executePostToTokenEndpoint.bind(this),
+            PerformanceEvents.BaseClientExecutePostToTokenEndpoint,
+            this.logger,
+            this.performanceClient,
             request.correlationId
-        )
-            .then((result) => {
-                acquireTokenMeasurement?.end({
-                    success: true,
-                });
-                return result;
-            })
-            .catch((error) => {
-                acquireTokenMeasurement?.end({
-                    success: false,
-                });
-                throw error;
-            });
+        )(endpoint, requestBody, headers, thumbprint, request.correlationId);
     }
 
     /**
@@ -327,11 +291,6 @@ export class RefreshTokenClient extends BaseClient {
         );
 
         const correlationId = request.correlationId;
-        const acquireTokenMeasurement =
-            this.performanceClient?.startMeasurement(
-                PerformanceEvents.BaseClientCreateTokenRequestHeaders,
-                correlationId
-            );
         const parameterBuilder = new RequestParameterBuilder();
 
         parameterBuilder.addClientId(this.config.authOptions.clientId);
@@ -380,21 +339,22 @@ export class RefreshTokenClient extends BaseClient {
                 this.cryptoUtils,
                 this.performanceClient
             );
-            this.performanceClient?.setPreQueueTime(
+            const reqCnfData = await invokeAsync(
+                popTokenGenerator.generateCnf.bind(popTokenGenerator),
                 PerformanceEvents.PopTokenGenerateCnf,
+                this.logger,
+                this.performanceClient,
                 request.correlationId
-            );
-            const reqCnfData = await popTokenGenerator.generateCnf(request);
+            )(request, this.logger);
             // SPA PoP requires full Base64Url encoded req_cnf string (unhashed)
             parameterBuilder.addPopToken(reqCnfData.reqCnfString);
         } else if (request.authenticationScheme === AuthenticationScheme.SSH) {
             if (request.sshJwk) {
                 parameterBuilder.addSshJwk(request.sshJwk);
             } else {
-                acquireTokenMeasurement?.end({
-                    success: false,
-                });
-                throw ClientConfigurationError.createMissingSshJwkError();
+                throw createClientConfigurationError(
+                    ClientConfigurationErrorCodes.missingSshJwk
+                );
             }
         }
 
@@ -434,9 +394,6 @@ export class RefreshTokenClient extends BaseClient {
                     break;
             }
         }
-        acquireTokenMeasurement?.end({
-            success: true,
-        });
         return parameterBuilder.createQueryString();
     }
 }

package/src/client/SilentFlowClient.ts

@@ -11,9 +11,13 @@ import { TimeUtils } from "../utils/TimeUtils";
 import { RefreshTokenClient } from "./RefreshTokenClient";
 import {
     ClientAuthError,
-    ClientAuthErrorMessage,
+    ClientAuthErrorCodes,
+    createClientAuthError,
 } from "../error/ClientAuthError";
-import { ClientConfigurationError } from "../error/ClientConfigurationError";
+import {
+    createClientConfigurationError,
+    ClientConfigurationErrorCodes,
+} from "../error/ClientConfigurationError";
 import { ResponseHandler } from "../response/ResponseHandler";
 import { CacheRecord } from "../cache/entities/CacheRecord";
 import { CacheOutcome } from "../utils/Constants";
@@ -40,11 +44,35 @@ export class SilentFlowClient extends BaseClient {
         request: CommonSilentFlowRequest
     ): Promise<AuthenticationResult> {
         try {
-            return await this.acquireCachedToken(request);
+            const [authResponse, cacheOutcome] = await this.acquireCachedToken(
+                request
+            );
+
+            // if the token is not expired but must be refreshed; get a new one in the background
+            if (cacheOutcome === CacheOutcome.PROACTIVELY_REFRESHED) {
+                this.logger.info(
+                    "SilentFlowClient:acquireCachedToken - Cached access token's refreshOn property has been exceeded'. It's not expired, but must be refreshed."
+                );
+
+                // refresh the access token in the background
+                const refreshTokenClient = new RefreshTokenClient(
+                    this.config,
+                    this.performanceClient
+                );
+
+                refreshTokenClient
+                    .acquireTokenByRefreshToken(request)
+                    .catch(() => {
+                        // do nothing, this is running in the background and no action is to be taken upon success or failure
+                    });
+            }
+
+            // return the cached token
+            return authResponse;
         } catch (e) {
             if (
                 e instanceof ClientAuthError &&
-                e.errorCode === ClientAuthErrorMessage.tokenRefreshRequired.code
+                e.errorCode === ClientAuthErrorCodes.tokenRefreshRequired
             ) {
                 const refreshTokenClient = new RefreshTokenClient(
                     this.config,
@@ -63,35 +91,47 @@ export class SilentFlowClient extends BaseClient {
      */
     async acquireCachedToken(
         request: CommonSilentFlowRequest
-    ): Promise<AuthenticationResult> {
+    ): Promise<[AuthenticationResult, CacheOutcome]> {
+        let lastCacheOutcome: CacheOutcome = CacheOutcome.NOT_APPLICABLE;
+
         // Cannot renew token if no request object is given.
         if (!request) {
-            throw ClientConfigurationError.createEmptyTokenRequestError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.tokenRequestEmpty
+            );
         }
 
         if (request.forceRefresh) {
             // Must refresh due to present force_refresh flag.
+            lastCacheOutcome = CacheOutcome.FORCE_REFRESH_OR_CLAIMS;
             this.serverTelemetryManager?.setCacheOutcome(
-                CacheOutcome.FORCE_REFRESH
+                CacheOutcome.FORCE_REFRESH_OR_CLAIMS
             );
             this.logger.info(
                 "SilentFlowClient:acquireCachedToken - Skipping cache because forceRefresh is true."
             );
-            throw ClientAuthError.createRefreshRequiredError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.tokenRefreshRequired
+            );
         } else if (
             !this.config.cacheOptions.claimsBasedCachingEnabled &&
             !StringUtils.isEmptyObj(request.claims)
         ) {
+            lastCacheOutcome = CacheOutcome.FORCE_REFRESH_OR_CLAIMS;
             // Must refresh due to request parameters.
             this.logger.info(
                 "SilentFlowClient:acquireCachedToken - Skipping cache because claims-based caching is disabled and claims were requested."
             );
-            throw ClientAuthError.createRefreshRequiredError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.tokenRefreshRequired
+            );
         }
 
         // We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases
         if (!request.account) {
-            throw ClientAuthError.createNoAccountInSilentRequestError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.noAccountInSilentRequest
+            );
         }
 
         const environment =
@@ -104,14 +144,17 @@ export class SilentFlowClient extends BaseClient {
         );
 
         if (!cacheRecord.accessToken) {
-            // Must refresh due to non-existent access_token.
+            // must refresh due to non-existent access_token
+            lastCacheOutcome = CacheOutcome.NO_CACHED_ACCESS_TOKEN;
             this.serverTelemetryManager?.setCacheOutcome(
                 CacheOutcome.NO_CACHED_ACCESS_TOKEN
             );
             this.logger.info(
                 "SilentFlowClient:acquireCachedToken - No access token found in cache for the given properties."
             );
-            throw ClientAuthError.createRefreshRequiredError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.tokenRefreshRequired
+            );
         } else if (
             TimeUtils.wasClockTurnedBack(cacheRecord.accessToken.cachedAt) ||
             TimeUtils.isTokenExpired(
@@ -119,33 +162,41 @@ export class SilentFlowClient extends BaseClient {
                 this.config.systemOptions.tokenRenewalOffsetSeconds
             )
         ) {
-            // Must refresh due to expired access_token.
+            // must refresh due to the expires_in value
+            lastCacheOutcome = CacheOutcome.CACHED_ACCESS_TOKEN_EXPIRED;
             this.serverTelemetryManager?.setCacheOutcome(
                 CacheOutcome.CACHED_ACCESS_TOKEN_EXPIRED
             );
             this.logger.info(
                 `SilentFlowClient:acquireCachedToken - Cached access token is expired or will expire within ${this.config.systemOptions.tokenRenewalOffsetSeconds} seconds.`
             );
-            throw ClientAuthError.createRefreshRequiredError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.tokenRefreshRequired
+            );
         } else if (
             cacheRecord.accessToken.refreshOn &&
             TimeUtils.isTokenExpired(cacheRecord.accessToken.refreshOn, 0)
         ) {
-            // Must refresh due to the refresh_in value.
+            // must refresh (in the background) due to the refresh_in value
+            lastCacheOutcome = CacheOutcome.PROACTIVELY_REFRESHED;
             this.serverTelemetryManager?.setCacheOutcome(
-                CacheOutcome.REFRESH_CACHED_ACCESS_TOKEN
+                CacheOutcome.PROACTIVELY_REFRESHED
             );
             this.logger.info(
                 "SilentFlowClient:acquireCachedToken - Cached access token's refreshOn property has been exceeded'."
             );
-            throw ClientAuthError.createRefreshRequiredError();
+
+            // don't throw ClientAuthError.createRefreshRequiredError(), return cached token instead
         }
 
         if (this.config.serverTelemetryManager) {
             this.config.serverTelemetryManager.incrementCacheHits();
         }
 
-        return await this.generateResultFromCacheRecord(cacheRecord, request);
+        return [
+            await this.generateResultFromCacheRecord(cacheRecord, request),
+            lastCacheOutcome,
+        ];
     }
 
     /**
@@ -168,7 +219,9 @@ export class SilentFlowClient extends BaseClient {
         if (request.maxAge || request.maxAge === 0) {
             const authTime = idTokenClaims?.auth_time;
             if (!authTime) {
-                throw ClientAuthError.createAuthTimeNotFoundError();
+                throw createClientAuthError(
+                    ClientAuthErrorCodes.authTimeNotFound
+                );
             }
 
             checkMaxAge(authTime, request.maxAge);

package/src/config/ClientConfiguration.ts

@@ -5,7 +5,6 @@
 
 import { INetworkModule } from "../network/INetworkModule";
 import { DEFAULT_CRYPTO_IMPLEMENTATION, ICrypto } from "../crypto/ICrypto";
-import { AuthError } from "../error/AuthError";
 import { ILoggerCallback, Logger, LogLevel } from "../logger/Logger";
 import { Constants } from "../utils/Constants";
 import { version } from "../packageMetadata";
@@ -17,6 +16,10 @@ import { ICachePlugin } from "../cache/interface/ICachePlugin";
 import { ISerializableTokenCache } from "../cache/interface/ISerializableTokenCache";
 import { ClientCredentials } from "../account/ClientCredentials";
 import { ProtocolMode } from "../authority/ProtocolMode";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 
 // Token renewal offset default in seconds
 const DEFAULT_TOKEN_RENEWAL_OFFSET_SEC = 300;
@@ -177,14 +180,10 @@ const DEFAULT_CACHE_OPTIONS: Required<CacheOptions> = {
 
 const DEFAULT_NETWORK_IMPLEMENTATION: INetworkModule = {
     async sendGetRequestAsync<T>(): Promise<T> {
-        const notImplErr =
-            "Network interface - sendGetRequestAsync() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     async sendPostRequestAsync<T>(): Promise<T> {
-        const notImplErr =
-            "Network interface - sendPostRequestAsync() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
 };
 

package/src/crypto/ICrypto.ts

@@ -3,7 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { AuthError } from "../error/AuthError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 import { BaseAuthRequest } from "../request/BaseAuthRequest";
 import { SignedHttpRequest } from "./SignedHttpRequest";
 
@@ -80,48 +83,30 @@ export interface ICrypto {
 
 export const DEFAULT_CRYPTO_IMPLEMENTATION: ICrypto = {
     createNewGuid: (): string => {
-        const notImplErr =
-            "Crypto interface - createNewGuid() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     base64Decode: (): string => {
-        const notImplErr =
-            "Crypto interface - base64Decode() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     base64Encode: (): string => {
-        const notImplErr =
-            "Crypto interface - base64Encode() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     async generatePkceCodes(): Promise<PkceCodes> {
-        const notImplErr =
-            "Crypto interface - generatePkceCodes() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     async getPublicKeyThumbprint(): Promise<string> {
-        const notImplErr =
-            "Crypto interface - getPublicKeyThumbprint() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     async removeTokenBindingKey(): Promise<boolean> {
-        const notImplErr =
-            "Crypto interface - removeTokenBindingKey() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     async clearKeystore(): Promise<boolean> {
-        const notImplErr =
-            "Crypto interface - clearKeystore() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     async signJwt(): Promise<string> {
-        const notImplErr =
-            "Crypto interface - signJwt() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
     async hashString(): Promise<string> {
-        const notImplErr =
-            "Crypto interface - hashString() has not been implemented";
-        throw AuthError.createUnexpectedError(notImplErr);
+        throw createClientAuthError(ClientAuthErrorCodes.methodNotImplemented);
     },
 };

package/src/crypto/JoseHeader.ts

@@ -3,7 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { JoseHeaderError } from "../error/JoseHeaderError";
+import {
+    JoseHeaderErrorCodes,
+    createJoseHeaderError,
+} from "../error/JoseHeaderError";
 import { JsonTypes } from "../utils/Constants";
 
 export type JoseHeaderOptions = {
@@ -35,12 +38,12 @@ export class JoseHeader {
     static getShrHeaderString(shrHeaderOptions: JoseHeaderOptions): string {
         // KeyID is required on the SHR header
         if (!shrHeaderOptions.kid) {
-            throw JoseHeaderError.createMissingKidError();
+            throw createJoseHeaderError(JoseHeaderErrorCodes.missingKidError);
         }
 
         // Alg is required on the SHR header
         if (!shrHeaderOptions.alg) {
-            throw JoseHeaderError.createMissingAlgError();
+            throw createJoseHeaderError(JoseHeaderErrorCodes.missingAlgError);
         }
 
         const shrHeader = new JoseHeader({