Polishing

Author: EmilianoSanchez

CHANGES.txt

@@ -1,5 +1,5 @@
 2.8.0 (October XX, 2025)
- - Added `client.whenReady()` and `client.whenReadyFromCache()` methods to replace the deprecated `client.ready()` method, which had an issue causing the returned promise to hang when using async/await syntax if it was rejected.
+ - Added `client.whenReady()` and `client.whenReadyFromCache()` methods to replace the deprecated `client.ready()` method, which has an issue causing the returned promise to hang when using async/await syntax if it was rejected.
  - Updated the SDK_READY_FROM_CACHE event to be emitted alongside the SDK_READY event if it hasn’t already been emitted.
 
 2.7.1 (October 8, 2025)

src/readiness/__tests__/sdkReadinessManager.spec.ts

@@ -1,11 +1,12 @@
 // @ts-nocheck
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 import SplitIO from '../../../types/splitio';
-import { SDK_READY, SDK_READY_FROM_CACHE, SDK_READY_TIMED_OUT, SDK_UPDATE } from '../constants';
+import { SDK_READY, SDK_READY_FROM_CACHE, SDK_READY_TIMED_OUT, SDK_UPDATE, SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../constants';
 import { sdkReadinessManagerFactory } from '../sdkReadinessManager';
 import { IReadinessManager } from '../types';
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../../logger/constants';
 import { fullSettings } from '../../utils/settingsValidation/__tests__/settings.mocks';
+import { EventEmitter } from '../../utils/MinEvents';
 
 const EventEmitterMock = jest.fn(() => ({
   on: jest.fn(),
@@ -24,6 +25,7 @@ function emitReadyEvent(readinessManager: IReadinessManager) {
   readinessManager.segments.once.mock.calls[0][1]();
   readinessManager.segments.on.mock.calls[0][1]();
   readinessManager.gate.once.mock.calls[0][1]();
+  if (readinessManager.gate.once.mock.calls[3]) readinessManager.gate.once.mock.calls[3][1](); // whenReady promise
 }
 
 const timeoutErrorMessage = 'Split SDK emitted SDK_READY_TIMED_OUT event.';
@@ -32,6 +34,7 @@ const timeoutErrorMessage = 'Split SDK emitted SDK_READY_TIMED_OUT event.';
 function emitTimeoutEvent(readinessManager: IReadinessManager) {
   readinessManager.gate.once.mock.calls[1][1](timeoutErrorMessage);
   readinessManager.hasTimedout = () => true;
+  if (readinessManager.gate.once.mock.calls[4]) readinessManager.gate.once.mock.calls[4][1](timeoutErrorMessage); // whenReady promise
 }
 
 describe('SDK Readiness Manager - Event emitter', () => {
@@ -50,7 +53,8 @@ describe('SDK Readiness Manager - Event emitter', () => {
       expect(sdkStatus[propName]).toBeTruthy(); // The sdkStatus exposes all minimal EventEmitter functionality.
     });
 
-    expect(typeof sdkStatus.ready).toBe('function'); // The sdkStatus exposes a .ready() function.
+    expect(typeof sdkStatus.whenReady).toBe('function'); // The sdkStatus exposes a .whenReady() function.
+    expect(typeof sdkStatus.whenReadyFromCache).toBe('function'); // The sdkStatus exposes a .whenReadyFromCache() function.
     expect(typeof sdkStatus.__getStatus).toBe('function'); // The sdkStatus exposes a .__getStatus() function.
     expect(sdkStatus.__getStatus()).toEqual({
       isReady: false, isReadyFromCache: false, isTimedout: false, hasTimedout: false, isDestroyed: false, isOperational: false, lastUpdate: 0
@@ -67,9 +71,9 @@ describe('SDK Readiness Manager - Event emitter', () => {
     const sdkReadyResolvePromiseCall = gateMock.once.mock.calls[0];
     const sdkReadyRejectPromiseCall = gateMock.once.mock.calls[1];
     const sdkReadyFromCacheListenersCheckCall = gateMock.once.mock.calls[2];
-    expect(sdkReadyResolvePromiseCall[0]).toBe(SDK_READY); // A one time only subscription is on the SDK_READY event, for resolving the full blown ready promise and to check for callbacks warning.
-    expect(sdkReadyRejectPromiseCall[0]).toBe(SDK_READY_TIMED_OUT); // A one time only subscription is also on the SDK_READY_TIMED_OUT event, for rejecting the full blown ready promise.
-    expect(sdkReadyFromCacheListenersCheckCall[0]).toBe(SDK_READY_FROM_CACHE); // A one time only subscription is on the SDK_READY_FROM_CACHE event, to log the event and update internal state.
+    expect(sdkReadyResolvePromiseCall[0]).toBe(SDK_READY); // A one time only subscription is on the SDK_READY event
+    expect(sdkReadyRejectPromiseCall[0]).toBe(SDK_READY_TIMED_OUT); // A one time only subscription is also on the SDK_READY_TIMED_OUT event
+    expect(sdkReadyFromCacheListenersCheckCall[0]).toBe(SDK_READY_FROM_CACHE); // A one time only subscription is on the SDK_READY_FROM_CACHE event
 
     expect(gateMock.on).toBeCalledTimes(2); // It should also add two persistent listeners
 
@@ -98,7 +102,7 @@ describe('SDK Readiness Manager - Event emitter', () => {
 
     emitReadyEvent(sdkReadinessManager.readinessManager);
 
-    expect(loggerMock.warn).toBeCalledTimes(1); // If the SDK_READY event fires and we have no callbacks for it (neither event nor ready promise) we get a warning.
+    expect(loggerMock.warn).toBeCalledTimes(1); // If the SDK_READY event fires and we have no callbacks for it (neither event nor whenReady promise) we get a warning.
     expect(loggerMock.warn).toBeCalledWith(CLIENT_NO_LISTENER); // Telling us there were no listeners and evaluations before this point may have been incorrect.
 
     expect(loggerMock.info).toBeCalledTimes(1); // If the SDK_READY event fires, we get a info message.
@@ -199,15 +203,15 @@ describe('SDK Readiness Manager - Event emitter', () => {
   });
 });
 
-describe('SDK Readiness Manager - Ready promise', () => {
+describe('SDK Readiness Manager - whenReady promise', () => {
 
-  test('.ready() promise behavior for clients', async () => {
+  test('.whenReady() promise behavior for clients', async () => {
     const sdkReadinessManager = sdkReadinessManagerFactory(EventEmitterMock, fullSettings);
 
-    const ready = sdkReadinessManager.sdkStatus.ready();
+    const ready = sdkReadinessManager.sdkStatus.whenReady();
     expect(ready instanceof Promise).toBe(true); // It should return a promise.
 
-    // make the SDK "ready"
+    // make the SDK ready
     emitReadyEvent(sdkReadinessManager.readinessManager);
 
     let testPassedCount = 0;
@@ -219,8 +223,8 @@ describe('SDK Readiness Manager - Ready promise', () => {
       () => { throw new Error('It should be resolved on ready event, not rejected.'); }
     );
 
-    // any subsequent call to .ready() must be a resolved promise
-    await ready.then(
+    // any subsequent call to .whenReady() must be a resolved promise
+    await sdkReadinessManager.sdkStatus.whenReady().then(
       () => {
         expect('A subsequent call should be a resolved promise.');
         testPassedCount++;
@@ -233,9 +237,9 @@ describe('SDK Readiness Manager - Ready promise', () => {
 
     const sdkReadinessManagerForTimedout = sdkReadinessManagerFactory(EventEmitterMock, fullSettings);
 
-    const readyForTimeout = sdkReadinessManagerForTimedout.sdkStatus.ready();
+    const readyForTimeout = sdkReadinessManagerForTimedout.sdkStatus.whenReady();
 
-    emitTimeoutEvent(sdkReadinessManagerForTimedout.readinessManager); // make the SDK "timed out"
+    emitTimeoutEvent(sdkReadinessManagerForTimedout.readinessManager); // make the SDK timeout
 
     await readyForTimeout.then(
       () => { throw new Error('It should be a promise that was rejected on SDK_READY_TIMED_OUT, not resolved.'); },
@@ -245,20 +249,20 @@ describe('SDK Readiness Manager - Ready promise', () => {
       }
     );
 
-    // any subsequent call to .ready() must be a rejected promise
-    await readyForTimeout.then(
+    // any subsequent call to .whenReady() must be a rejected promise until the SDK is ready
+    await sdkReadinessManagerForTimedout.sdkStatus.whenReady().then(
       () => { throw new Error('It should be a promise that was rejected on SDK_READY_TIMED_OUT, not resolved.'); },
       () => {
         expect('A subsequent call should be a rejected promise.');
         testPassedCount++;
       }
     );
 
-    // make the SDK "ready"
+    // make the SDK ready
     emitReadyEvent(sdkReadinessManagerForTimedout.readinessManager);
 
-    // once SDK_READY, `.ready()` returns a resolved promise
-    await ready.then(
+    // once SDK_READY, `.whenReady()` returns a resolved promise
+    await sdkReadinessManagerForTimedout.sdkStatus.whenReady().then(
       () => {
         expect('It should be a resolved promise when the SDK is ready, even after an SDK timeout.');
         loggerMock.mockClear();
@@ -269,7 +273,35 @@ describe('SDK Readiness Manager - Ready promise', () => {
     );
   });
 
-  test('Full blown ready promise count as a callback and resolves on SDK_READY', (done) => {
+  test('whenReady promise count as a callback and resolves on SDK_READY', (done) => {
+    let sdkReadinessManager = sdkReadinessManagerFactory(EventEmitter, fullSettings);
+
+    // Emit ready event
+    sdkReadinessManager.readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
+    sdkReadinessManager.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+
+    expect(loggerMock.warn).toBeCalledWith(CLIENT_NO_LISTENER); // We should get a warning if the SDK get's ready before calling the whenReady method or attaching a listener to the ready event
+    loggerMock.warn.mockClear();
+
+    sdkReadinessManager = sdkReadinessManagerFactory(EventEmitter, fullSettings);
+    sdkReadinessManager.sdkStatus.whenReady().then(() => {
+      expect('whenReady promise is resolved when the gate emits SDK_READY.');
+      done();
+    }, () => {
+      throw new Error('This should not be called as the promise is being resolved.');
+    });
+
+    // Emit ready event
+    sdkReadinessManager.readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
+    sdkReadinessManager.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+
+    expect(loggerMock.warn).not.toBeCalled(); // But if we have a listener or call the whenReady method, we get no warnings.
+  });
+});
+
+// @TODO: remove in next major
+describe('SDK Readiness Manager - Ready promise', () => {
+  test('ready promise count as a callback and resolves on SDK_READY', (done) => {
     const sdkReadinessManager = sdkReadinessManagerFactory(EventEmitterMock, fullSettings);
     const readyPromise = sdkReadinessManager.sdkStatus.ready();
 

src/readiness/sdkReadinessManager.ts

@@ -9,7 +9,7 @@ import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO
 
 const NEW_LISTENER_EVENT = 'newListener';
 const REMOVE_LISTENER_EVENT = 'removeListener';
-const TIMEOUT_ERROR = new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.');
+const TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
@@ -98,7 +98,7 @@ export function sdkReadinessManagerFactory(
         ready() {
           if (readinessManager.hasTimedout()) {
             if (!readinessManager.isReady()) {
-              return promiseWrapper(Promise.reject(TIMEOUT_ERROR), defaultOnRejected);
+              return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
             } else {
               return Promise.resolve();
             }