@splitsoftware/splitio-commons 3.1.1-rc.4 → 3.1.1-rc.6

package/src/sync/streaming/AuthClient/types.ts

@@ -1,23 +1,19 @@
 import { IDecodedJWTToken } from '../../../utils/jwt/types';
 
-export type IJwtCredentialV2 = {
-  pushEnabled: boolean
-  token: string // empty string ("") when `"pushEnabled": false`
-  decodedToken: IDecodedJWTToken
-  channels: { [channel: string]: string[] }
-  connDelay?: number
-}
-
-export type IJwtCredentialV3 = {
-  token: string
+export type IJwtCredential = {
+  token: string; // empty string ("") when `"pushEnabled": false`
   decodedToken: IDecodedJWTToken
   channels: { [channel: string]: string[] }
+  // /api/v2/auth fields
+  pushEnabled?: boolean | null;
+  connDelay?: number | null;
+  // /api/v3/auth fields
   config?: {
     streaming?: {
-      delay?: number
-      enabled?: boolean
+      delay?: number | null;
+      enabled?: boolean | null;
     } | null;
   } | null;
 }
 
-export type IAuthenticate = (userKeys?: string[]) => Promise<IJwtCredentialV2>
+export type IFetchAuth = (userKeys?: string[]) => Promise<IJwtCredential>

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

@@ -5,7 +5,7 @@ import { ISettings } from '../../../types';
 import { checkIfServerSide } from '../../../utils/key';
 import { isString } from '../../../utils/lang';
 import { objectAssign } from '../../../utils/lang/objectAssign';
-import { IJwtCredentialV2 } from '../AuthClient/types';
+import { IJwtCredential } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
 
 const ABLY_API_VERSION = '1.1';
@@ -66,7 +66,7 @@ export class SSEClient implements ISSEClient {
   /**
    * Open the connection with a given authToken
    */
-  open(authToken: IJwtCredentialV2) {
+  open(authToken: IJwtCredential) {
     this.close(); // it closes connection if previously opened
 
     const channelsQueryParam = Object.keys(authToken.channels).map((channel) => {

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

@@ -1,4 +1,4 @@
-import { IJwtCredentialV2 } from '../AuthClient/types';
+import { IJwtCredential } from '../AuthClient/types';
 
 export interface ISseEventHandler {
   handleError: (ev: Event) => any;
@@ -7,7 +7,7 @@ export interface ISseEventHandler {
 }
 
 export interface ISSEClient {
-  open(authToken: IJwtCredentialV2): void,
+  open(authToken: IJwtCredential): void,
   close(): void,
   setEventHandler(handler: ISseEventHandler): void
 }

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

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, CONFIG_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -80,6 +80,7 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       switch (parsedData.type) {
         /* update events */
         case SPLIT_UPDATE:
+        case CONFIG_UPDATE:
         case SEGMENT_UPDATE:
         case MEMBERSHIPS_MS_UPDATE:
         case MEMBERSHIPS_LS_UPDATE:

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

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE, RB_SEGMENT_UPDATE } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, CONFIG_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE, RB_SEGMENT_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -42,7 +42,7 @@ export interface ISegmentUpdateData {
 }
 
 export interface ISplitUpdateData {
-  type: SPLIT_UPDATE | RB_SEGMENT_UPDATE,
+  type: SPLIT_UPDATE | CONFIG_UPDATE | RB_SEGMENT_UPDATE,
   changeNumber: number,
   pcn?: number,
   d?: string,

package/src/sync/streaming/constants.ts

@@ -30,6 +30,7 @@ export const MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export const SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export const SPLIT_KILL = 'SPLIT_KILL';
 export const SPLIT_UPDATE = 'SPLIT_UPDATE';
+export const CONFIG_UPDATE = 'CONFIG_UPDATE';
 export const RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper

package/src/sync/streaming/pushManager.ts

@@ -7,16 +7,15 @@ import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
 import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
-import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_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 { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, CONFIG_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';
 import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
-import { IJwtCredentialV2 } from './AuthClient/types';
+import { IJwtCredential } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
@@ -45,7 +44,6 @@ export function pushManagerFactory(
     log.warn(STREAMING_FALLBACK, [e]);
     return;
   }
-  const authenticate = authenticateFactory(serviceApi.fetchAuth);
 
   // init feedback loop
   const pushEmitter = new platform.EventEmitter() as IPushEventEmitter;
@@ -58,8 +56,6 @@ export function pushManagerFactory(
   // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
   const definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
 
-  // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
-  const userKeyHashes: Record<string, string> = {};
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
   const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker> }> = {};
@@ -81,7 +77,7 @@ export function pushManagerFactory(
   let timeoutIdTokenRefresh: ReturnType<typeof setTimeout>;
   let timeoutIdSseOpen: ReturnType<typeof setTimeout>;
 
-  function scheduleTokenRefreshAndSse(authData: IJwtCredentialV2) {
+  function scheduleTokenRefreshAndSse(authData: IJwtCredential) {
     // clear scheduled tasks if exist
     if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
     if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
@@ -113,41 +109,37 @@ export function pushManagerFactory(
     disconnected = false;
 
     const userKeys = userKey ? Object.keys(clients) : undefined;
-    authenticate(userKeys).then(
-      function (authData) {
-        if (disconnected) return;
-
-        // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
-        // close the sseClient in case the org has been bloqued while the instance was connected to streaming
-        if (!authData.pushEnabled) {
-          log.info(STREAMING_DISABLED);
-          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
-          return;
-        }
-
-        // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
-        if (userKeys && userKeys.length < Object.keys(clients).length) return;
+    serviceApi.fetchAuth(userKeys).then((authData) => {
+      if (disconnected) return;
 
-        // Schedule SSE connection and refresh token
-        scheduleTokenRefreshAndSse(authData);
+      // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+      // close the sseClient in case the org has been bloqued while the instance was connected to streaming
+      if (!authData.pushEnabled) {
+        log.info(STREAMING_DISABLED);
+        pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
+        return;
       }
-    ).catch(
-      function (error) {
-        if (disconnected) return;
 
-        log.error(ERROR_STREAMING_AUTH, [error.message]);
+      // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
+      if (userKeys && userKeys.length < Object.keys(clients).length) return;
 
-        // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
-        if (error.statusCode >= 400 && error.statusCode < 500) {
-          telemetryTracker.streamingEvent(AUTH_REJECTION);
-          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
-          return;
-        }
+      // Schedule SSE connection and refresh token
+      scheduleTokenRefreshAndSse(authData);
+    }).catch((error) => {
+      if (disconnected) return;
 
-        // Handle other HTTP and network errors as recoverable errors
-        pushEmitter.emit(PUSH_RETRYABLE_ERROR);
+      log.error(ERROR_STREAMING_AUTH, [error.message]);
+
+      // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
+      if (error.statusCode >= 400 && error.statusCode < 500) {
+        telemetryTracker.streamingEvent(AUTH_REJECTION);
+        pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
+        return;
       }
-    );
+
+      // Handle other HTTP and network errors as recoverable errors
+      pushEmitter.emit(PUSH_RETRYABLE_ERROR);
+    });
   }
 
   // close SSE connection and cancel scheduled tasks
@@ -218,8 +210,11 @@ export function pushManagerFactory(
 
   /** Functions related to synchronization (Queues and Workers in the spec) */
 
+  // Some notification types are specific to the Feature flags or Configs SDKs. Their handlers are
+  // registered unconditionally, since the SDK only subscribes to the channels of its own entities.
   pushEmitter.on(SPLIT_KILL, definitionsUpdateWorker.killDefinition);
   pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+  pushEmitter.on(CONFIG_UPDATE, definitionsUpdateWorker.put);
   pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
 
   function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
@@ -324,10 +319,7 @@ export function pushManagerFactory(
 
       // [Only for client-side]
       add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask) {
-        const hash = hashUserKey(userKey);
-
-        if (!userKeyHashes[hash]) {
-          userKeyHashes[hash] = userKey;
+        if (!clients[userKey]) {
           clients[userKey] = {
             hash64: hash64(userKey),
             worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
@@ -349,8 +341,6 @@ export function pushManagerFactory(
       },
       // [Only for client-side]
       remove(userKey: string) {
-        const hash = hashUserKey(userKey);
-        delete userKeyHashes[hash];
         delete clients[userKey];
       }
     }

package/src/sync/streaming/types.ts

@@ -16,19 +16,20 @@ export type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
+export type CONFIG_UPDATE = 'CONFIG_UPDATE';
 export type RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NON_RETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NON_RETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | CONFIG_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
   T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :
   T extends MEMBERSHIPS_LS_UPDATE ? IMembershipLSUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
-  T extends SPLIT_UPDATE | RB_SEGMENT_UPDATE ? ISplitUpdateData :
+  T extends SPLIT_UPDATE | CONFIG_UPDATE | RB_SEGMENT_UPDATE ? ISplitUpdateData :
   T extends SPLIT_KILL ? ISplitKillData : INotificationData;
 
 /**

package/src/sync/submitters/submitterManager.ts

@@ -5,44 +5,70 @@ import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { ISubmitterManager } from './types';
 import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
+import { SDK_READY } from '../../readiness/constants';
 
-export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager {
+/**
+ * Creates a submitter manager.
+ *
+ * @param startWhenReady - If true, the submitters will only start and execute the underlying submitters when the SDK is ready.
+ * `true` for Configs SDK, `false` for Flags SDKs.
+ */
+export function submitterManagerFactory(startWhenReady?: boolean) {
 
-  const submitters = [
-    impressionsSubmitterFactory(params),
-    eventsSubmitterFactory(params),
-    impressionCountsSubmitterFactory(params),
-    uniqueKeysSubmitterFactory(params)
-  ];
+  return function (params: ISdkFactoryContextSync): ISubmitterManager {
 
-  const telemetrySubmitter = telemetrySubmitterFactory(params);
+    const { readiness } = params;
+
+    const submitters = [
+      impressionsSubmitterFactory(params),
+      eventsSubmitterFactory(params),
+      impressionCountsSubmitterFactory(params),
+      uniqueKeysSubmitterFactory(params)
+    ];
+
+    const telemetrySubmitter = telemetrySubmitterFactory(params);
+    let isRunning = false;
+
+    function startSubmitters(onlyTelemetry?: boolean) {
+      if (!isRunning) return;
 
-  return {
-    // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
-    start(onlyTelemetry?: boolean) {
       if (!onlyTelemetry) submitters.forEach(submitter => submitter.start());
       if (telemetrySubmitter) telemetrySubmitter.start();
-    },
-
-    // `allExceptTelemetry` true if userConsent is changed to DECLINED
-    stop(allExceptTelemetry?: boolean) {
-      submitters.forEach(submitter => submitter.stop());
-      if (!allExceptTelemetry && telemetrySubmitter) telemetrySubmitter.stop();
-    },
-
-    isRunning() {
-      return submitters.some(submitter => submitter.isRunning());
-    },
-
-    // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
-    execute(onlyTelemetry?: boolean) {
-      const promises = onlyTelemetry ? [] : submitters.map(submitter => submitter.execute());
-      if (telemetrySubmitter) promises.push(telemetrySubmitter.execute());
-      return Promise.all(promises).then(() => { });
-    },
-
-    isExecuting() {
-      return submitters.some(submitter => submitter.isExecuting());
     }
+
+    return {
+      // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
+      start(onlyTelemetry?: boolean) {
+        isRunning = true;
+
+        if (!startWhenReady || readiness.isReady()) startSubmitters(onlyTelemetry);
+        else readiness.gate.once(SDK_READY, () => startSubmitters(onlyTelemetry));
+      },
+
+      // `allExceptTelemetry` true if userConsent is changed to DECLINED
+      stop(allExceptTelemetry?: boolean) {
+        isRunning = false;
+
+        submitters.forEach(submitter => submitter.stop());
+        if (!allExceptTelemetry && telemetrySubmitter) telemetrySubmitter.stop();
+      },
+
+      isRunning() {
+        return isRunning;
+      },
+
+      // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
+      execute(onlyTelemetry?: boolean) {
+        if (startWhenReady && !readiness.isReady()) return Promise.resolve();
+
+        const promises = onlyTelemetry ? [] : submitters.map(submitter => submitter.execute());
+        if (telemetrySubmitter) promises.push(telemetrySubmitter.execute());
+        return Promise.all(promises).then(() => { });
+      },
+
+      isExecuting() {
+        return submitters.some(submitter => submitter.isExecuting());
+      }
+    };
   };
 }

package/src/sync/syncManagerOnline.ts

@@ -19,10 +19,12 @@ import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
+ * @param submitterManagerFactory - specify the submitter manager factory to use
  */
 export function syncManagerOnlineFactory(
   pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,
   pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
+  _submitterManagerFactory = submitterManagerFactory(),
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
@@ -42,7 +44,7 @@ export function syncManagerOnlineFactory(
 
     /** Submitter Manager */
     // It is not injected as push and polling managers, because at the moment it is required
-    const submitterManager = submitterManagerFactory(params);
+    const submitterManager = _submitterManagerFactory(params);
 
     /** Sync Manager logic */