@aws-amplify/ui-react-liveness 3.0.12 → 3.0.14

package/dist/esm/components/FaceLivenessDetector/LivenessCheck/LivenessCameraModule.mjs

@@ -79,22 +79,15 @@ const LivenessCameraModule = (props) => {
     const [mediaHeight, setMediaHeight] = useState(videoHeight);
     const [aspectRatio, setAspectRatio] = useState(() => videoWidth && videoHeight ? videoWidth / videoHeight : 0);
     React__default.useEffect(() => {
-        if (canvasRef &&
-            videoRef &&
-            canvasRef.current &&
-            videoRef.current &&
-            videoStream &&
-            isStartView) {
+        if (canvasRef?.current && videoRef?.current && videoStream && isStartView) {
             drawStaticOval(canvasRef.current, videoRef.current, videoStream);
         }
     }, [canvasRef, videoRef, videoStream, colorMode, isStartView]);
     React__default.useEffect(() => {
         const updateColorModeHandler = (e) => {
             if (e.matches &&
-                canvasRef &&
-                videoRef &&
-                canvasRef.current &&
-                videoRef.current &&
+                canvasRef?.current &&
+                videoRef?.current &&
                 videoStream &&
                 isStartView) {
                 drawStaticOval(canvasRef.current, videoRef.current, videoStream);

package/dist/esm/components/FaceLivenessDetector/service/machine/index.mjs

@@ -1,3 +1,4 @@
+import { nanoid } from 'nanoid';
 import { createMachine, assign, spawn, actions } from 'xstate';
 import { drawStaticOval, getBoundingBox, getColorsSequencesFromSessionInformation, isCameraDeviceVirtual, getFaceMatchState, isFaceDistanceBelowThreshold, estimateIllumination, getOvalDetailsFromSessionInformation, generateBboxFromLandmarks, drawLivenessOvalInCanvas, getOvalBoundingBox, getIntersectionOverUnion, getFaceMatchStateInLivenessOval, getStaticLivenessOvalDetails } from '../utils/liveness.mjs';
 import { FaceMatchState } from '../types/liveness.mjs';
@@ -5,16 +6,68 @@ import { LivenessErrorState } from '../types/error.mjs';
 import { BlazeFaceFaceDetection } from '../utils/blazefaceFaceDetection.mjs';
 import { LivenessStreamProvider } from '../utils/streamProvider.mjs';
 import { FreshnessColorDisplay } from '../utils/freshnessColorDisplay.mjs';
-import { nanoid } from 'nanoid';
 import { isServerSesssionInformationEvent, isDisconnectionEvent, isValidationExceptionEvent, isInternalServerExceptionEvent, isThrottlingExceptionEvent, isServiceQuotaExceededExceptionEvent, isInvalidSignatureRegionException } from '../utils/eventUtils.mjs';
 import { STATIC_VIDEO_CONSTRAINTS } from '../../utils/helpers.mjs';
 import { WS_CLOSURE_CODE } from '../utils/constants.mjs';
 
-/* eslint-disable */
-const MIN_FACE_MATCH_TIME = 1000;
+const CAMERA_ID_KEY = 'AmplifyLivenessCameraId';
 const DEFAULT_FACE_FIT_TIMEOUT = 7000;
+const MIN_FACE_MATCH_TIME = 1000;
 let responseStream;
-const CAMERA_ID_KEY = 'AmplifyLivenessCameraId';
+const responseStreamActor = async (callback) => {
+    try {
+        const stream = await responseStream;
+        for await (const event of stream) {
+            if (isServerSesssionInformationEvent(event)) {
+                callback({
+                    type: 'SET_SESSION_INFO',
+                    data: {
+                        sessionInfo: event.ServerSessionInformationEvent.SessionInformation,
+                    },
+                });
+            }
+            else if (isDisconnectionEvent(event)) {
+                callback({ type: 'DISCONNECT_EVENT' });
+            }
+            else if (isValidationExceptionEvent(event)) {
+                callback({
+                    type: 'SERVER_ERROR',
+                    data: { error: { ...event.ValidationException } },
+                });
+            }
+            else if (isInternalServerExceptionEvent(event)) {
+                callback({
+                    type: 'SERVER_ERROR',
+                    data: { error: { ...event.InternalServerException } },
+                });
+            }
+            else if (isThrottlingExceptionEvent(event)) {
+                callback({
+                    type: 'SERVER_ERROR',
+                    data: { error: { ...event.ThrottlingException } },
+                });
+            }
+            else if (isServiceQuotaExceededExceptionEvent(event)) {
+                callback({
+                    type: 'SERVER_ERROR',
+                    data: { error: { ...event.ServiceQuotaExceededException } },
+                });
+            }
+        }
+    }
+    catch (error) {
+        let returnedError = error;
+        if (isInvalidSignatureRegionException(error)) {
+            returnedError = new Error('Invalid region in FaceLivenessDetector or credentials are scoped to the wrong region.');
+        }
+        if (returnedError instanceof Error) {
+            callback({
+                type: 'SERVER_ERROR',
+                data: { error: returnedError },
+            });
+        }
+    }
+};
 function getLastSelectedCameraId() {
     return localStorage.getItem(CAMERA_ID_KEY);
 }
@@ -99,12 +152,12 @@ const livenessMachine = createMachine({
     },
     states: {
         cameraCheck: {
-            entry: ['resetErrorState'],
+            entry: 'resetErrorState',
             invoke: {
                 src: 'checkVirtualCameraAndGetStream',
                 onDone: {
                     target: 'waitForDOMAndCameraDetails',
-                    actions: ['updateVideoMediaStream'],
+                    actions: 'updateVideoMediaStream',
                 },
                 onError: {
                     target: 'permissionDenied',
@@ -137,7 +190,7 @@ const livenessMachine = createMachine({
                 src: 'detectFace',
                 onDone: {
                     target: 'checkFaceDetectedBeforeStart',
-                    actions: ['updateFaceMatchBeforeStartDetails'],
+                    actions: 'updateFaceMatchBeforeStartDetails',
                 },
             },
         },
@@ -155,7 +208,7 @@ const livenessMachine = createMachine({
                 src: 'detectFaceDistance',
                 onDone: {
                     target: 'checkFaceDistanceBeforeRecording',
-                    actions: ['updateFaceDistanceBeforeRecording'],
+                    actions: 'updateFaceDistanceBeforeRecording',
                 },
             },
         },
@@ -199,7 +252,7 @@ const livenessMachine = createMachine({
             initial: 'ovalDrawing',
             states: {
                 ovalDrawing: {
-                    entry: ['sendTimeoutAfterOvalDrawingDelay'],
+                    entry: 'sendTimeoutAfterOvalDrawingDelay',
                     invoke: {
                         src: 'detectInitialFaceAndDrawOval',
                         onDone: {
@@ -229,13 +282,13 @@ const livenessMachine = createMachine({
                         0: {
                             target: 'ovalMatching',
                             cond: 'hasRecordingStarted',
-                            actions: ['updateRecordingStartTimestampMs'],
+                            actions: 'updateRecordingStartTimestampMs',
                         },
                         100: { target: 'checkRecordingStarted' },
                     },
                 },
                 ovalMatching: {
-                    entry: ['cancelOvalDrawingTimeout'],
+                    entry: 'cancelOvalDrawingTimeout',
                     invoke: {
                         src: 'detectFaceAndMatchOval',
                         onDone: {
@@ -283,7 +336,7 @@ const livenessMachine = createMachine({
                     },
                 },
                 success: {
-                    entry: ['stopRecording'],
+                    entry: 'stopRecording',
                     type: 'final',
                 },
             },
@@ -336,13 +389,11 @@ const livenessMachine = createMachine({
         },
         permissionDenied: {
             entry: 'callUserPermissionDeniedCallback',
-            on: {
-                RETRY_CAMERA_CHECK: 'cameraCheck',
-            },
+            on: { RETRY_CAMERA_CHECK: 'cameraCheck' },
         },
         mobileLandscapeWarning: {
             entry: 'callMobileLandscapeWarningCallback',
-            always: [{ target: 'error' }],
+            always: { target: 'error' },
         },
         timeout: {
             entry: ['cleanUpResources', 'callUserTimeoutCallback', 'freezeStream'],
@@ -359,7 +410,7 @@ const livenessMachine = createMachine({
         },
         userCancel: {
             entry: ['cleanUpResources', 'callUserCancelCallback', 'resetContext'],
-            always: [{ target: 'cameraCheck' }],
+            always: { target: 'cameraCheck' },
         },
     },
 }, {
@@ -368,16 +419,17 @@ const livenessMachine = createMachine({
             responseStreamActorRef: () => spawn(responseStreamActor),
         }),
         updateFailedAttempts: assign({
-            failedAttempts: (context) => {
-                return context.failedAttempts + 1;
-            },
+            failedAttempts: (context) => context.failedAttempts + 1,
         }),
         updateVideoMediaStream: assign({
             videoAssociatedParams: (context, event) => ({
                 ...context.videoAssociatedParams,
-                videoMediaStream: event.data?.stream,
-                selectedDeviceId: event.data?.selectedDeviceId,
-                selectableDevices: event.data?.selectableDevices,
+                videoMediaStream: event.data
+                    ?.stream,
+                selectedDeviceId: event.data
+                    ?.selectedDeviceId,
+                selectableDevices: event.data
+                    ?.selectableDevices,
             }),
         }),
         initializeFaceDetector: assign({
@@ -386,29 +438,23 @@ const livenessMachine = createMachine({
                 const { faceModelUrl, binaryPath } = componentProps.config;
                 const faceDetector = new BlazeFaceFaceDetection(binaryPath, faceModelUrl);
                 faceDetector.triggerModelLoading();
-                return {
-                    ...context.ovalAssociatedParams,
-                    faceDetector,
-                };
+                return { ...context.ovalAssociatedParams, faceDetector };
             },
         }),
         updateLivenessStreamProvider: assign({
-            livenessStreamProvider: (context, event) => {
-                return event.data?.livenessStreamProvider;
-            },
+            livenessStreamProvider: (context, event) => event.data?.livenessStreamProvider,
         }),
         setDOMAndCameraDetails: assign({
-            videoAssociatedParams: (context, event) => {
-                return {
-                    ...context.videoAssociatedParams,
-                    videoEl: event.data?.videoEl,
-                    canvasEl: event.data?.canvasEl,
-                    isMobile: event.data?.isMobile,
-                };
-            },
+            videoAssociatedParams: (context, event) => ({
+                ...context.videoAssociatedParams,
+                videoEl: event.data?.videoEl,
+                canvasEl: event.data?.canvasEl,
+                isMobile: event.data?.isMobile,
+            }),
             freshnessColorAssociatedParams: (context, event) => ({
                 ...context.freshnessColorAssociatedParams,
-                freshnessColorEl: event.data?.freshnessColorEl,
+                freshnessColorEl: event.data
+                    ?.freshnessColorEl,
             }),
         }),
         updateDeviceAndStream: assign({
@@ -416,8 +462,10 @@ const livenessMachine = createMachine({
                 setLastSelectedCameraId(event.data?.newDeviceId);
                 return {
                     ...context.videoAssociatedParams,
-                    selectedDeviceId: event.data?.newDeviceId,
-                    videoMediaStream: event.data?.newStream,
+                    selectedDeviceId: event.data
+                        ?.newDeviceId,
+                    videoMediaStream: event.data
+                        ?.newStream,
                 };
             },
         }),
@@ -478,50 +526,49 @@ const livenessMachine = createMachine({
                         'recording') {
                     context.livenessStreamProvider.startRecordingLivenessVideo();
                 }
-                return {
-                    ...context.videoAssociatedParams,
-                };
+                return { ...context.videoAssociatedParams };
             },
         }),
-        stopRecording: (context) => { },
+        stopRecording: () => { },
         updateFaceMatchBeforeStartDetails: assign({
-            faceMatchStateBeforeStart: (_, event) => {
-                return event.data.faceMatchState;
-            },
+            faceMatchStateBeforeStart: (_, event) => event.data.faceMatchState,
         }),
         updateFaceDistanceBeforeRecording: assign({
-            isFaceFarEnoughBeforeRecording: (_, event) => {
-                return event.data.isFaceFarEnoughBeforeRecording;
-            },
+            isFaceFarEnoughBeforeRecording: (_, event) => !!event.data.isFaceFarEnoughBeforeRecording,
         }),
         updateFaceDistanceWhileLoading: assign({
-            isFaceFarEnoughBeforeRecording: (_, event) => {
-                return event.data.isFaceFarEnoughBeforeRecording;
-            },
-            errorState: (_, event) => {
-                return event.data?.error;
-            },
+            isFaceFarEnoughBeforeRecording: (_, event) => !!event.data.isFaceFarEnoughBeforeRecording,
+            errorState: (_, event) => event.data?.error,
         }),
         updateOvalAndFaceDetailsPostDraw: assign({
             ovalAssociatedParams: (context, event) => ({
                 ...context.ovalAssociatedParams,
-                initialFace: event.data.initialFace,
-                ovalDetails: event.data.ovalDetails,
-                scaleFactor: event.data.scaleFactor,
+                initialFace: event.data
+                    .initialFace,
+                ovalDetails: event.data
+                    .ovalDetails,
+                scaleFactor: event.data
+                    .scaleFactor,
             }),
             faceMatchAssociatedParams: (context, event) => ({
                 ...context.faceMatchAssociatedParams,
-                faceMatchState: event.data.faceMatchState,
-                illuminationState: event.data.illuminationState,
+                faceMatchState: event.data
+                    .faceMatchState,
+                illuminationState: event.data
+                    .illuminationState,
             }),
         }),
         updateFaceDetailsPostMatch: assign({
             faceMatchAssociatedParams: (context, event) => ({
                 ...context.faceMatchAssociatedParams,
-                faceMatchState: event.data.faceMatchState,
-                faceMatchPercentage: event.data.faceMatchPercentage,
-                illuminationState: event.data.illuminationState,
-                currentDetectedFace: event.data.detectedFace,
+                faceMatchState: event.data
+                    .faceMatchState,
+                faceMatchPercentage: event.data
+                    .faceMatchPercentage,
+                illuminationState: event.data
+                    .illuminationState,
+                currentDetectedFace: event.data
+                    .detectedFace,
             }),
         }),
         updateEndFaceMatch: assign({
@@ -544,40 +591,30 @@ const livenessMachine = createMachine({
                 };
             },
         }),
-        resetErrorState: assign({
-            errorState: (_) => undefined,
-        }),
+        resetErrorState: assign({ errorState: (_) => undefined }),
         updateErrorStateForTimeout: assign({
-            errorState: (_, event) => {
-                return event.data?.errorState || LivenessErrorState.TIMEOUT;
-            },
+            errorState: (_, event) => event.data?.errorState || LivenessErrorState.TIMEOUT,
         }),
         updateErrorStateForRuntime: assign({
-            errorState: (_, event) => {
-                return event.data?.errorState || LivenessErrorState.RUNTIME_ERROR;
-            },
+            errorState: (_, event) => event.data?.errorState ||
+                LivenessErrorState.RUNTIME_ERROR,
         }),
         updateErrorStateForServer: assign({
             errorState: (_) => LivenessErrorState.SERVER_ERROR,
         }),
-        clearErrorState: assign({
-            errorState: (_) => undefined,
-        }),
+        clearErrorState: assign({ errorState: (_) => undefined }),
         updateSessionInfo: assign({
-            serverSessionInformation: (context, event) => {
+            serverSessionInformation: (_, event) => {
                 return event.data.sessionInfo;
             },
         }),
-        updateShouldDisconnect: assign({
-            shouldDisconnect: (context) => {
-                return true;
-            },
-        }),
+        updateShouldDisconnect: assign({ shouldDisconnect: () => true }),
         updateFreshnessDetails: assign({
             freshnessColorAssociatedParams: (context, event) => {
                 return {
                     ...context.freshnessColorAssociatedParams,
-                    freshnessColorsComplete: event.data.freshnessColorsComplete,
+                    freshnessColorsComplete: event.data
+                        .freshnessColorsComplete,
                 };
             },
         }),
@@ -602,7 +639,7 @@ const livenessMachine = createMachine({
             delay: (context) => {
                 return (context.serverSessionInformation?.Challenge
                     ?.FaceMovementAndLightChallenge?.ChallengeConfig
-                    ?.OvalFitTimeout || DEFAULT_FACE_FIT_TIMEOUT);
+                    ?.OvalFitTimeout ?? DEFAULT_FACE_FIT_TIMEOUT);
             },
             id: 'ovalMatchTimeout',
         }),
@@ -644,14 +681,12 @@ const livenessMachine = createMachine({
             },
         }),
         callMobileLandscapeWarningCallback: assign({
-            errorState: (context) => {
-                return LivenessErrorState.MOBILE_LANDSCAPE_ERROR;
-            },
+            errorState: () => LivenessErrorState.MOBILE_LANDSCAPE_ERROR,
         }),
-        callUserCancelCallback: async (context) => {
+        callUserCancelCallback: (context) => {
             context.componentProps.onUserCancel?.();
         },
-        callUserTimeoutCallback: async (context) => {
+        callUserTimeoutCallback: (context) => {
             const error = new Error('Client Timeout');
             error.name = context.errorState;
             const livenessError = {
@@ -660,14 +695,14 @@ const livenessMachine = createMachine({
             };
             context.componentProps.onError?.(livenessError);
         },
-        callErrorCallback: async (context, event) => {
+        callErrorCallback: (context, event) => {
             const livenessError = {
                 state: context.errorState,
                 error: event.data?.error || event.data,
             };
             context.componentProps.onError?.(livenessError);
         },
-        cleanUpResources: async (context) => {
+        cleanUpResources: (context) => {
             const { freshnessColorEl } = context.freshnessColorAssociatedParams;
             if (freshnessColorEl) {
                 freshnessColorEl.style.display = 'none';
@@ -686,9 +721,9 @@ const livenessMachine = createMachine({
             else if (context.errorState === undefined) {
                 closureCode = WS_CLOSURE_CODE.USER_CANCEL;
             }
-            await context.livenessStreamProvider?.endStreamWithCode(closureCode);
+            context.livenessStreamProvider?.endStreamWithCode(closureCode);
         },
-        freezeStream: async (context) => {
+        freezeStream: (context) => {
             const { videoMediaStream, videoEl } = context.videoAssociatedParams;
             context.isRecordingStopped = true;
             videoEl?.pause();
@@ -696,7 +731,7 @@ const livenessMachine = createMachine({
                 track.stop();
             });
         },
-        pauseVideoStream: async (context) => {
+        pauseVideoStream: (context) => {
             const { videoEl } = context.videoAssociatedParams;
             context.isRecordingStopped = true;
             videoEl.pause();
@@ -752,7 +787,6 @@ const livenessMachine = createMachine({
         hasNotEnoughFaceDistanceBeforeRecording: (context) => {
             return !context.isFaceFarEnoughBeforeRecording;
         },
-        hasLivenessCheckSucceeded: (_, __, meta) => meta.state.event.data.isLive,
         hasFreshnessColorShown: (context) => context.freshnessColorAssociatedParams.freshnessColorsComplete,
         hasServerSessionInfo: (context) => {
             return context.serverSessionInformation !== undefined;
@@ -805,14 +839,15 @@ const livenessMachine = createMachine({
             // If the initial stream is of real camera, use it otherwise use the first real camera
             const initialStreamDeviceId = tracksWithMoreThan15Fps[0].getSettings().deviceId;
             const isInitialStreamFromRealDevice = realVideoDevices.some((device) => device.deviceId === initialStreamDeviceId);
-            let deviceId = initialStreamDeviceId;
+            const deviceId = isInitialStreamFromRealDevice
+                ? initialStreamDeviceId
+                : realVideoDevices[0].deviceId;
             let realVideoDeviceStream = initialStream;
             if (!isInitialStreamFromRealDevice) {
-                deviceId = realVideoDevices[0].deviceId;
                 realVideoDeviceStream = await navigator.mediaDevices.getUserMedia({
                     video: {
                         ...videoConstraints,
-                        deviceId: { exact: realVideoDevices[0].deviceId },
+                        deviceId: { exact: deviceId },
                     },
                     audio: false,
                 });
@@ -824,6 +859,7 @@ const livenessMachine = createMachine({
                 selectableDevices: realVideoDevices,
             };
         },
+        // eslint-disable-next-line @typescript-eslint/require-await
         async openLivenessStreamConnection(context) {
             const { config } = context.componentProps;
             const { credentialProvider, endpointOverride } = config;
@@ -846,6 +882,7 @@ const livenessMachine = createMachine({
                 await faceDetector.modelLoadingPromise;
             }
             catch (err) {
+                // eslint-disable-next-line no-console
                 console.log({ err });
             }
             // detect face
@@ -885,10 +922,11 @@ const livenessMachine = createMachine({
             });
             const { isDistanceBelowThreshold: isFaceFarEnoughBeforeRecording, error, } = await isFaceDistanceBelowThreshold({
                 faceDetector: faceDetector,
-                videoEl: videoEl,
+                isMobile,
                 ovalDetails,
+                videoEl: videoEl,
+                // if this is the second face distance check reduce the threshold
                 reduceThreshold: faceDistanceCheckBeforeRecording,
-                isMobile,
             });
             return { isFaceFarEnoughBeforeRecording, error };
         },
@@ -902,6 +940,7 @@ const livenessMachine = createMachine({
                 await livenessStreamProvider.videoRecorder.recorderStarted;
             }
             catch (err) {
+                // eslint-disable-next-line no-console
                 console.log({ err });
             }
             // detect face
@@ -917,6 +956,7 @@ const livenessMachine = createMachine({
                     break;
                 }
                 case 1: {
+                    //exactly one face detected;
                     faceMatchState = FaceMatchState.FACE_IDENTIFIED;
                     initialFace = detectedFaces[0];
                     break;
@@ -1063,7 +1103,7 @@ const livenessMachine = createMachine({
                 throw new Error('Video chunks not recorded successfully.');
             }
             livenessStreamProvider.sendClientInfo(livenessActionDocument);
-            await livenessStreamProvider.dispatchStopVideoEvent();
+            livenessStreamProvider.dispatchStopVideoEvent();
         },
         async getLiveness(context) {
             const { onAnalysisComplete } = context.componentProps;
@@ -1072,59 +1112,5 @@ const livenessMachine = createMachine({
         },
     },
 });
-const responseStreamActor = async (callback) => {
-    try {
-        const stream = await responseStream;
-        for await (const event of stream) {
-            if (isServerSesssionInformationEvent(event)) {
-                callback({
-                    type: 'SET_SESSION_INFO',
-                    data: {
-                        sessionInfo: event.ServerSessionInformationEvent.SessionInformation,
-                    },
-                });
-            }
-            else if (isDisconnectionEvent(event)) {
-                callback({ type: 'DISCONNECT_EVENT' });
-            }
-            else if (isValidationExceptionEvent(event)) {
-                callback({
-                    type: 'SERVER_ERROR',
-                    data: { error: { ...event.ValidationException } },
-                });
-            }
-            else if (isInternalServerExceptionEvent(event)) {
-                callback({
-                    type: 'SERVER_ERROR',
-                    data: { error: { ...event.InternalServerException } },
-                });
-            }
-            else if (isThrottlingExceptionEvent(event)) {
-                callback({
-                    type: 'SERVER_ERROR',
-                    data: { error: { ...event.ThrottlingException } },
-                });
-            }
-            else if (isServiceQuotaExceededExceptionEvent(event)) {
-                callback({
-                    type: 'SERVER_ERROR',
-                    data: { error: { ...event.ServiceQuotaExceededException } },
-                });
-            }
-        }
-    }
-    catch (error) {
-        let returnedError = error;
-        if (isInvalidSignatureRegionException(error)) {
-            returnedError = new Error('Invalid region in FaceLivenessDetector or credentials are scoped to the wrong region.');
-        }
-        if (returnedError instanceof Error) {
-            callback({
-                type: 'SERVER_ERROR',
-                data: { error: returnedError },
-            });
-        }
-    }
-};
 
-export { MIN_FACE_MATCH_TIME, livenessMachine };
+export { livenessMachine };

package/dist/esm/components/FaceLivenessDetector/service/utils/CustomWebSocketFetchHandler.mjs

@@ -23,10 +23,10 @@ const getIterator = (stream) => {
         return stream;
     }
     if (isReadableStream(stream)) {
-        //If stream is a ReadableStream, transfer the ReadableStream to async iterable.
+        // If stream is a ReadableStream, transfer the ReadableStream to async iterable.
         return readableStreamtoIterable(stream);
     }
-    //For other types, just wrap them with an async iterable.
+    // For other types, just wrap them with an async iterable.
     return {
         [Symbol.asyncIterator]: async function* () {
             yield stream;
@@ -85,8 +85,7 @@ class CustomWebSocketFetchHandler {
         }
         this.sockets[url].push(socket);
         socket.binaryType = 'arraybuffer';
-        const { connectionTimeout = DEFAULT_WS_CONNECTION_TIMEOUT_MS } = await this
-            .configPromise;
+        const { connectionTimeout = DEFAULT_WS_CONNECTION_TIMEOUT_MS } = await this.configPromise;
         await this.waitForReady(socket, connectionTimeout);
         const { body } = request;
         const bodyStream = getIterator(body);