@splitsoftware/splitio-commons 2.7.9-rc.0 → 2.7.9-rc.2

package/src/readiness/sdkReadinessManager.ts

@@ -9,6 +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(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).
@@ -38,6 +39,8 @@ export function sdkReadinessManagerFactory(
       } else if (event === SDK_READY) {
         readyCbCount++;
       }
+    } else if (event === SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
+      log.error(ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
     }
   });
 
@@ -69,6 +72,17 @@ export function sdkReadinessManagerFactory(
     return promise;
   }
 
+  function getStatus() {
+    return {
+      isReady: readinessManager.isReady(),
+      isReadyFromCache: readinessManager.isReadyFromCache(),
+      isTimedout: readinessManager.isTimedout(),
+      hasTimedout: readinessManager.hasTimedout(),
+      isDestroyed: readinessManager.isDestroyed(),
+      isOperational: readinessManager.isOperational(),
+      lastUpdate: readinessManager.lastUpdate(),
+    };
+  }
 
   return {
     readinessManager,
@@ -93,6 +107,7 @@ export function sdkReadinessManagerFactory(
           SDK_READY_TIMED_OUT,
         },
 
+        // @TODO: remove in next major
         ready() {
           if (readinessManager.hasTimedout()) {
             if (!readinessManager.isReady()) {
@@ -104,17 +119,35 @@ export function sdkReadinessManagerFactory(
           return readyPromise;
         },
 
-        __getStatus() {
-          return {
-            isReady: readinessManager.isReady(),
-            isReadyFromCache: readinessManager.isReadyFromCache(),
-            isTimedout: readinessManager.isTimedout(),
-            hasTimedout: readinessManager.hasTimedout(),
-            isDestroyed: readinessManager.isDestroyed(),
-            isOperational: readinessManager.isOperational(),
-            lastUpdate: readinessManager.lastUpdate(),
-          };
+        whenReady() {
+          return new Promise<void>((resolve, reject) => {
+            if (readinessManager.isReady()) {
+              resolve();
+            } else if (readinessManager.hasTimedout()) {
+              reject(TIMEOUT_ERROR);
+            } else {
+              readinessManager.gate.once(SDK_READY, resolve);
+              readinessManager.gate.once(SDK_READY_TIMED_OUT, () => reject(TIMEOUT_ERROR));
+            }
+          });
+        },
+
+        whenReadyFromCache() {
+          return new Promise<boolean>((resolve, reject) => {
+            if (readinessManager.isReadyFromCache()) {
+              resolve(readinessManager.isReady());
+            } else if (readinessManager.hasTimedout()) {
+              reject(TIMEOUT_ERROR);
+            } else {
+              readinessManager.gate.once(SDK_READY_FROM_CACHE, () => resolve(readinessManager.isReady()));
+              readinessManager.gate.once(SDK_READY_TIMED_OUT, () => reject(TIMEOUT_ERROR));
+            }
+          });
         },
+
+        getStatus,
+        // @TODO: remove in next major
+        __getStatus: getStatus
       }
     )
   };

package/src/readiness/types.ts

@@ -1,4 +1,3 @@
-import { IStatusInterface } from '../types';
 import SplitIO from '../../types/splitio';
 
 /** Splits data emitter */
@@ -72,7 +71,7 @@ export interface IReadinessManager {
 
 export interface ISdkReadinessManager {
   readinessManager: IReadinessManager
-  sdkStatus: IStatusInterface
+  sdkStatus: SplitIO.IStatusInterface
 
   /**
    * Increment internalReadyCbCount, an offset value of SDK_READY listeners that are added/removed internally

package/src/sdkClient/client.ts

@@ -51,7 +51,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatment;
     };
 
-    const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+    const evaluation = readinessManager.isReadyFromCache() ?
       evaluateFeature(log, key, featureFlagName, attributes, storage) :
       isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         Promise.resolve(treatmentNotReady) :
@@ -80,7 +80,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatments;
     };
 
-    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+    const evaluations = readinessManager.isReadyFromCache() ?
       evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
       isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         Promise.resolve(treatmentsNotReady(featureFlagNames)) :
@@ -109,7 +109,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatments;
     };
 
-    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+    const evaluations = readinessManager.isReadyFromCache() ?
       evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
       isAsync ?
         Promise.resolve({}) :
@@ -149,7 +149,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     if (treatment === CONTROL) {
       const fallbackTreatment = fallbackTreatmentsCalculator.resolve(featureFlagName, label);
       treatment = fallbackTreatment.treatment;
-      label = fallbackTreatment.label ? fallbackTreatment.label : label;
+      label = fallbackTreatment.label;
       config = fallbackTreatment.config;
     }
 

package/src/sdkClient/clientInputValidation.ts

@@ -8,7 +8,7 @@ import {
   validateSplits,
   validateTrafficType,
   validateIfNotDestroyed,
-  validateIfOperational,
+  validateIfReadyFromCache,
   validateEvaluationOptions
 } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
@@ -46,7 +46,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
     const options = validateEvaluationOptions(log, maybeOptions, methodName);
 
-    validateIfOperational(log, readinessManager, methodName, nameOrNames);
+    validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
 
     const valid = isNotDestroyed && key && nameOrNames && attributes !== false;
 
@@ -60,7 +60,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function evaluateFallBackTreatment(featureFlagName: string, withConfig: boolean): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
-    const {treatment, config} = fallbackTreatmentsCalculator.resolve(featureFlagName, '');
+    const { treatment, config } = fallbackTreatmentsCalculator.resolve(featureFlagName, '');
 
     if (withConfig) {
       return {

package/src/sdkManager/index.ts

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
+import { validateSplit, validateSplitExistence, validateIfOperational } from '../utils/inputValidation';
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
@@ -66,7 +66,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       split(featureFlagName: string) {
         const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
-        if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
+        if (!validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
           return isAsync ? Promise.resolve(null) : null;
         }
 
@@ -87,7 +87,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        * Get the feature flag objects present on the factory storage
        */
       splits() {
-        if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
+        if (!validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
           return isAsync ? Promise.resolve([]) : [];
         }
         const currentSplits = splits.getAll();
@@ -100,7 +100,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        * Get the feature flag names present on the factory storage
        */
       names() {
-        if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
+        if (!validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
           return isAsync ? Promise.resolve([]) : [];
         }
         const splitNames = splits.getSplitNames();

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -1,5 +1,6 @@
 import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload, UpdatesFromSSEEnum, UpdatesFromSSE } from '../../sync/submitters/types';
 import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
+import { checkIfServerSide } from '../../utils/key';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 
@@ -20,7 +21,7 @@ const ACCEPTANCE_RANGE = 0.001;
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
 export function shouldRecordTelemetry({ settings }: IStorageFactoryParams) {
-  return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
+  return settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
 }
 
 export class TelemetryCacheInMemory implements ITelemetryCacheSync {

package/src/storages/pluggable/index.ts

@@ -21,6 +21,7 @@ import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS
 import { metadataBuilder } from '../utils';
 import { LOG_PREFIX } from '../pluggable/constants';
 import { RBSegmentsCachePluggable } from './RBSegmentsCachePluggable';
+import { checkIfServerSide } from '../../utils/key';
 
 const NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 const NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
@@ -83,7 +84,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper);
 
     const uniqueKeysCache = isPartialConsumer ?
-      settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
+      checkIfServerSide(settings) ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
       new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper);
 
     // Connects to wrapper and emits SDK_READY event on main client

package/src/sync/polling/fetchers/splitChangesFetcher.ts

@@ -6,6 +6,7 @@ import { FLAG_SPEC_VERSION } from '../../../utils/constants';
 import { base } from '../../../utils/settingsValidation';
 import { ISplitChangesFetcher } from './types';
 import { LOG_PREFIX_SYNC_SPLITS } from '../../../logger/constants';
+import { checkIfServerSide } from '../../../utils/key';
 
 const PROXY_CHECK_INTERVAL_MILLIS_CS = 60 * 60 * 1000; // 1 hour in Client Side
 const PROXY_CHECK_INTERVAL_MILLIS_SS = 24 * PROXY_CHECK_INTERVAL_MILLIS_CS; // 24 hours in Server Side
@@ -22,7 +23,7 @@ function sdkEndpointOverridden(settings: ISettings) {
 export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges, settings: ISettings, storage: Pick<IStorageBase, 'splits' | 'rbSegments'>): ISplitChangesFetcher {
 
   const log = settings.log;
-  const PROXY_CHECK_INTERVAL_MILLIS = settings.core.key !== undefined ? PROXY_CHECK_INTERVAL_MILLIS_CS : PROXY_CHECK_INTERVAL_MILLIS_SS;
+  const PROXY_CHECK_INTERVAL_MILLIS = checkIfServerSide(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
   let lastProxyCheckTimestamp: number | undefined;
 
   return function splitChangesFetcher(

package/src/sync/streaming/SSEClient/index.ts

@@ -2,6 +2,7 @@ import { IPlatform } from '../../../sdkFactory/types';
 import { decorateHeaders } from '../../../services/decorateHeaders';
 import { IEventSourceConstructor } from '../../../services/types';
 import { ISettings } from '../../../types';
+import { checkIfServerSide } from '../../../utils/key';
 import { isString } from '../../../utils/lang';
 import { objectAssign } from '../../../utils/lang/objectAssign';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
@@ -73,7 +74,7 @@ export class SSEClient implements ISSEClient {
       return encodeURIComponent(params + channel);
     }).join(',');
     const url = `${this.settings.urls.streaming}/sse?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
-    const isServerSide = !this.settings.core.key;
+    const isServerSide = checkIfServerSide(this.settings);
 
     this.connection = new this.eventSource!(
       // For client-side SDKs, metadata is passed as query param to avoid CORS issues and because native EventSource implementations in browsers do not support headers

package/src/sync/streaming/SSEHandler/index.ts

@@ -25,7 +25,7 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       const code = error.parsedData.code;
       telemetryTracker.streamingEvent(ABLY_ERROR, code);
 
-      // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
+      // 401 errors due to invalid or expired token (e.g., if refresh token couldn't be executed)
       if (40140 <= code && code <= 40149) return true;
       // Others 4XX errors (e.g., bad request from the SDK)
       if (40000 <= code && code <= 49999) return false;

package/src/sync/streaming/pushManager.ts

@@ -10,7 +10,7 @@ import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
-import { getMatching } from '../../utils/key';
+import { checkIfServerSide, getMatching } from '../../utils/key';
 import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
@@ -34,7 +34,7 @@ export function pushManagerFactory(
 
   // `userKey` is the matching key of main client in client-side SDK.
   // It can be used to check if running on client-side or server-side SDK.
-  const userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
+  const userKey = checkIfServerSide(settings) ? undefined : getMatching(settings.core.key);
   const log = settings.log;
 
   let sseClient: ISSEClient;

package/src/sync/submitters/telemetrySubmitter.ts

@@ -11,6 +11,7 @@ import { timer } from '../../utils/timeTracker/timer';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { ISplitFiltersValidation } from '../../dtos/types';
+import { checkIfServerSide } from '../../utils/key';
 
 const OPERATION_MODE_MAP = {
   [STANDALONE_MODE]: STANDALONE_ENUM,
@@ -72,7 +73,7 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
 
     pop(): TelemetryConfigStatsPayload {
       const { urls, scheduler } = settings;
-      const isClientSide = settings.core.key !== undefined;
+      const isServerSide = checkIfServerSide(settings);
 
       const { flagSetsTotal, flagSetsIgnored } = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation);
 
@@ -80,8 +81,8 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
         sE: settings.streamingEnabled,
         rR: {
           sp: scheduler.featuresRefreshRate / 1000,
-          se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
-          ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+          se: isServerSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+          ms: isServerSide ? undefined : scheduler.segmentsRefreshRate / 1000,
           im: scheduler.impressionsRefreshRate / 1000,
           ev: scheduler.eventsPushRate / 1000,
           te: scheduler.telemetryRefreshRate / 1000,
@@ -119,7 +120,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
   const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
-  const startTime = timer(now);
+  const stopTimer = timer(now);
 
   const submitter = firstPushWindowDecorator(
     submitterFactory(
@@ -131,12 +132,12 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   );
 
   readiness.gate.once(SDK_READY_FROM_CACHE, () => {
-    telemetry.recordTimeUntilReadyFromCache(startTime());
+    telemetry.recordTimeUntilReadyFromCache(stopTimer());
   });
 
   sdkReadinessManager.incInternalReadyCbCount();
   readiness.gate.once(SDK_READY, () => {
-    telemetry.recordTimeUntilReady(startTime());
+    telemetry.recordTimeUntilReady(stopTimer());
 
     // Post config data when the SDK is ready and if the telemetry submitter was started
     if (submitter.isRunning()) {

package/src/trackers/telemetryTracker.ts

@@ -11,11 +11,11 @@ export function telemetryTrackerFactory(
 ): ITelemetryTracker {
 
   if (telemetryCache && now) {
-    const startTime = timer(now);
+    const sessionTimer = timer(now);
 
     return {
       trackEval(method) {
-        const evalTime = timer(now);
+        const evalTimer = timer(now);
 
         return (label) => {
           switch (label) {
@@ -25,20 +25,20 @@ export function telemetryTrackerFactory(
             case SDK_NOT_READY: // @ts-ignore ITelemetryCacheAsync doesn't implement the method
               if (telemetryCache.recordNonReadyUsage) telemetryCache.recordNonReadyUsage();
           }
-          telemetryCache.recordLatency(method, evalTime());
+          telemetryCache.recordLatency(method, evalTimer());
         };
       },
       trackHttp(operation) {
-        const httpTime = timer(now);
+        const httpTimer = timer(now);
 
         return (error) => {
-          (telemetryCache as ITelemetryCacheSync).recordHttpLatency(operation, httpTime());
+          (telemetryCache as ITelemetryCacheSync).recordHttpLatency(operation, httpTimer());
           if (error && error.statusCode) (telemetryCache as ITelemetryCacheSync).recordHttpError(operation, error.statusCode);
           else (telemetryCache as ITelemetryCacheSync).recordSuccessfulSync(operation, Date.now());
         };
       },
       sessionLength() { // @ts-ignore ITelemetryCacheAsync doesn't implement the method
-        if (telemetryCache.recordSessionLength) telemetryCache.recordSessionLength(startTime());
+        if (telemetryCache.recordSessionLength) telemetryCache.recordSessionLength(sessionTimer());
       },
       streamingEvent(e, d) {
         if (e === AUTH_REJECTION) {

package/src/types.ts

@@ -14,21 +14,6 @@ export interface ISettings extends SplitIO.ISettings {
   readonly initialRolloutPlan?: RolloutPlan;
 }
 
-/**
- * SplitIO.IStatusInterface interface extended with private properties for internal use
- */
-export interface IStatusInterface extends SplitIO.IStatusInterface {
-  // Expose status for internal purposes only. Not considered part of the public API, and might be updated eventually.
-  __getStatus(): {
-    isReady: boolean;
-    isReadyFromCache: boolean;
-    isTimedout: boolean;
-    hasTimedout: boolean;
-    isDestroyed: boolean;
-    isOperational: boolean;
-    lastUpdate: number;
-  };
-}
 /**
  * SplitIO.IBasicClient interface extended with private properties for internal use
  */

package/src/utils/inputValidation/index.ts

@@ -7,7 +7,7 @@ export { validateKey } from './key';
 export { validateSplit } from './split';
 export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
-export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
+export { validateIfNotDestroyed, validateIfReadyFromCache, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validateEvaluationOptions } from './eventProperties';

package/src/utils/inputValidation/isOperational.ts

@@ -1,4 +1,4 @@
-import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY } from '../../logger/constants';
+import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY_FROM_CACHE } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { IReadinessManager } from '../../readiness/types';
 
@@ -9,9 +9,14 @@ export function validateIfNotDestroyed(log: ILogger, readinessManager: IReadines
   return false;
 }
 
-export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
-  if (readinessManager.isReady() || readinessManager.isReadyFromCache()) return true;
+export function validateIfReadyFromCache(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
+  if (readinessManager.isReadyFromCache()) return true;
 
-  log.warn(CLIENT_NOT_READY, [method, featureFlagNameOrNames ? ` for feature flag ${featureFlagNameOrNames.toString()}` : '']);
+  log.warn(CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? ` for feature flag ${featureFlagNameOrNames.toString()}` : '']);
   return false;
 }
+
+// Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
+export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
+  return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
+}

package/src/utils/inputValidation/splitExistence.ts

@@ -5,11 +5,11 @@ import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
 
 /**
  * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.
+ * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
  */
 export function validateSplitExistence(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean {
-  if (readinessManager.isReady()) { // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.
-    if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND) {
+  if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
+    if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
       log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
       return false;
     }

package/src/utils/key/index.ts

@@ -1,4 +1,5 @@
 import SplitIO from '../../../types/splitio';
+import { ISettings } from '../../types';
 import { isObject } from '../lang';
 
 // function isSplitKeyObject(key: any): key is SplitIO.SplitKeyObject {
@@ -32,3 +33,7 @@ export function keyParser(key: SplitIO.SplitKey): SplitIO.SplitKeyObject {
     };
   }
 }
+
+export function checkIfServerSide(settings: ISettings) {
+  return !settings.core.key;
+}

package/types/splitio.d.ts

@@ -93,6 +93,7 @@ interface ISharedSettings {
   urls?: SplitIO.UrlSettings;
   /**
    * Custom logger object. If not provided, the SDK will use the default `console.log` method for all log levels.
+   * Set together with `debug` option to `true` or a log level string to enable logging.
    */
   logger?: SplitIO.Logger;
 }
@@ -145,8 +146,6 @@ interface IPluggableSharedSettings {
    * config.debug = ErrorLogger()
    * ```
    *
-   * When combined with the `logger` option, any log level other than `NONE` (false) will be set to `DEBUG` (true), delegating log level control to the custom logger.
-   *
    * @defaultValue `false`
    */
   debug?: boolean | SplitIO.LogLevel | SplitIO.ILogger;
@@ -170,8 +169,6 @@ interface INonPluggableSharedSettings {
    * config.debug = 'WARN'
    * ```
    *
-   * When combined with the `logger` option, any log level other than `NONE` (false) will be set to `DEBUG` (true), delegating log level control to the custom logger.
-   *
    * @defaultValue `false`
    */
   debug?: boolean | SplitIO.LogLevel;
@@ -528,19 +525,19 @@ declare namespace SplitIO {
    */
   type EventConsts = {
     /**
-     * The ready event.
+     * The ready event emitted once the SDK is ready to evaluate feature flags with cache synchronized with the backend.
      */
     SDK_READY: 'init::ready';
     /**
-     * The ready event when fired with cached data.
+     * The ready event emitted once the SDK is ready to evaluate feature flags with cache that could be stale. Use SDK_READY if you want to be sure the cache is in sync with the backend.
      */
     SDK_READY_FROM_CACHE: 'init::cache-ready';
     /**
-     * The timeout event.
+     * The timeout event emitted after `startup.readyTimeout` seconds if the SDK_READY event was not emitted.
      */
     SDK_READY_TIMED_OUT: 'init::timeout';
     /**
-     * The update event.
+     * The update event emitted when the SDK cache is updated with new data from the backend.
      */
     SDK_UPDATE: 'state::update';
   };
@@ -698,6 +695,52 @@ declare namespace SplitIO {
       [status in ConsentStatus]: ConsentStatus;
     };
   }
+  /**
+   * Readiness Status interface. It represents the readiness state of an SDK client.
+   */
+  interface ReadinessStatus {
+
+    /**
+     * `isReady` indicates if the client has triggered an `SDK_READY` event and
+     * thus is ready to evaluate with cached data synchronized with the backend.
+     */
+    isReady: boolean;
+
+    /**
+     * `isReadyFromCache` indicates if the client has triggered an `SDK_READY_FROM_CACHE` event and
+     * thus is ready to evaluate with cached data, although the data in cache might be stale, not synchronized with the backend.
+     */
+    isReadyFromCache: boolean;
+
+    /**
+     * `isTimedout` indicates if the client has triggered an `SDK_READY_TIMED_OUT` event and is not ready to evaluate.
+     * In other words, `isTimedout` is equivalent to `hasTimedout && !isReady`.
+     */
+    isTimedout: boolean;
+
+    /**
+     * `hasTimedout` indicates if the client has ever triggered an `SDK_READY_TIMED_OUT` event.
+     * It's meant to keep a reference that the SDK emitted a timeout at some point, not the current state.
+     */
+    hasTimedout: boolean;
+
+    /**
+     * `isDestroyed` indicates if the client has been destroyed, i.e., `destroy` method has been called.
+     */
+    isDestroyed: boolean;
+
+    /**
+     * `isOperational` indicates if the client can evaluate feature flags.
+     * In this state, `getTreatment` calls will not return `CONTROL` due to the SDK being unready or destroyed.
+     * It's equivalent to `isReadyFromCache && !isDestroyed`.
+     */
+    isOperational: boolean;
+
+    /**
+     * `lastUpdate` indicates the timestamp of the most recent status event.
+     */
+    lastUpdate: number;
+  }
   /**
    * Common API for entities that expose status handlers.
    */
@@ -707,7 +750,13 @@ declare namespace SplitIO {
      */
     Event: EventConsts;
     /**
-     * Returns a promise that resolves once the SDK has finished loading (`SDK_READY` event emitted) or rejected if the SDK has timedout (`SDK_READY_TIMED_OUT` event emitted).
+     * Gets the readiness status.
+     *
+     * @returns The current readiness status.
+     */
+    getStatus(): ReadinessStatus;
+    /**
+     * Returns a promise that resolves when the SDK has finished initial synchronization with the backend (`SDK_READY` event emitted), or rejected if the SDK has timedout (`SDK_READY_TIMED_OUT` event emitted).
      * As it's meant to provide similar flexibility to the event approach, given that the SDK might be eventually ready after a timeout event, the `ready` method will return a resolved promise once the SDK is ready.
      *
      * Caveats: the method was designed to avoid an unhandled Promise rejection if the rejection case is not handled, so that `onRejected` handler is optional when using promises.
@@ -722,8 +771,26 @@ declare namespace SplitIO {
      * ```
      *
      * @returns A promise that resolves once the SDK is ready or rejects if the SDK has timedout.
+     * @deprecated Use `whenReady` instead.
      */
     ready(): Promise<void>;
+    /**
+     * Returns a promise that resolves when the SDK has finished initial synchronization with the backend (`SDK_READY` event emitted), or rejected if the SDK has timedout (`SDK_READY_TIMED_OUT` event emitted).
+     * As it's meant to provide similar flexibility than event listeners, given that the SDK might be ready after a timeout event, the `whenReady` method will return a resolved promise once the SDK is ready.
+     * You must handle the promise rejection to avoid an unhandled promise rejection error, or set the `startup.readyTimeout` configuration option to 0 to avoid the timeout and thus the rejection.
+     *
+     * @returns A promise that resolves once the SDK_READY event is emitted or rejects if the SDK has timedout.
+     */
+    whenReady(): Promise<void>;
+    /**
+     * Returns a promise that resolves when the SDK is ready for evaluations using cached data, which might not yet be synchronized with the backend (`SDK_READY_FROM_CACHE` event emitted), or rejected if the SDK has timedout (`SDK_READY_TIMED_OUT` event emitted).
+     * As it's meant to provide similar flexibility than event listeners, given that the SDK might be ready from cache after a timeout event, the `whenReadyFromCache` method will return a resolved promise once the SDK is ready from cache.
+     * You must handle the promise rejection to avoid an unhandled promise rejection error, or set the `startup.readyTimeout` configuration option to 0 to avoid the timeout and thus the rejection.
+     *
+     * @returns A promise that resolves once the SDK_READY_FROM_CACHE event is emitted or rejects if the SDK has timedout. The promise resolves with a boolean value that
+     * indicates whether the SDK_READY_FROM_CACHE event was emitted together with the SDK_READY event (i.e., the SDK is ready and synchronized with the backend) or not.
+     */
+    whenReadyFromCache(): Promise<boolean>;
   }
   /**
    * Common definitions between clients for different environments interface.
@@ -1666,7 +1733,7 @@ declare namespace SplitIO {
      * Wait for the SDK client to be ready before calling this method.
      *
      * ```js
-     * await factory.client().ready();
+     * await factory.client().whenReady();
      * const rolloutPlan = factory.getRolloutPlan();
      * ```
      *

package/cjs/evaluator/fallbackTreatmentsCalculator/constants.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FallbackDiscardReason = void 0;
-var FallbackDiscardReason;
-(function (FallbackDiscardReason) {
-    FallbackDiscardReason["FlagName"] = "Invalid flag name (max 100 chars, no spaces)";
-    FallbackDiscardReason["Treatment"] = "Invalid treatment (max 100 chars and must match pattern)";
-})(FallbackDiscardReason = exports.FallbackDiscardReason || (exports.FallbackDiscardReason = {}));