Updated the factory 'init' and 'destroy' methods to support re-initialization after destruction

Author: EmilianoSanchez

CHANGES.txt

@@ -1,3 +1,6 @@
+2.0.1 (XXX XX, 2024)
+ - Updated the factory `init` and `destroy` methods to support re-initialization after destruction, enabling repeated cycles of initialization and cleanup. This update ensures compatibility of the React SDK with React Strict Mode, where the factory's `init` and `destroy` effects are executed an extra time to validate proper resource cleanup.
+
 2.0.0 (November 1, 2024)
  - Added support for targeting rules based on large segments.
  - Added `factory.destroy()` method, which invokes the `destroy` method on all SDK clients created by the factory.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.0.0",
+  "version": "2.0.1-rc.0",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package.json

@@ -37,7 +37,9 @@ function segmentsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitt
 export function readinessManagerFactory(
   EventEmitter: new () => SplitIO.IEventEmitter,
   settings: ISettings,
-  splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
+  splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter),
+  isShared?: boolean
+): IReadinessManager {
 
   const readyTimeout = settings.startup.readyTimeout;
 
@@ -66,23 +68,26 @@ export function readinessManagerFactory(
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
   }
 
-  let readyTimeoutId: ReturnType<typeof setTimeout>;
-  if (readyTimeout > 0) {
-    if (splits.hasInit) readyTimeoutId = setTimeout(timeout, readyTimeout);
-    else splits.initCallbacks.push(() => { readyTimeoutId = setTimeout(timeout, readyTimeout); });
-  }
 
   // emit SDK_READY and SDK_UPDATE
   let isReady = false;
   splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
   segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
 
   let isDestroyed = false;
+  let readyTimeoutId: ReturnType<typeof setTimeout>;
+  function __init() {
+    isDestroyed = false;
+    if (readyTimeout > 0 && !isReady) readyTimeoutId = setTimeout(timeout, readyTimeout);
+  }
+
+  splits.initCallbacks.push(__init);
+  if (splits.hasInit) __init();
 
   function checkIsReadyFromCache() {
     isReadyFromCache = true;
     // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
-    if (!isReady) {
+    if (!isReady && !isDestroyed) {
       try {
         syncLastUpdate();
         gate.emit(SDK_READY_FROM_CACHE);
@@ -94,6 +99,7 @@ export function readinessManagerFactory(
   }
 
   function checkIsReadyOrUpdate(diff: any) {
+    if (isDestroyed) return;
     if (isReady) {
       try {
         syncLastUpdate();
@@ -117,16 +123,13 @@ export function readinessManagerFactory(
     }
   }
 
-  let refCount = 1;
-
   return {
     splits,
     segments,
     gate,
 
     shared() {
-      refCount++;
-      return readinessManagerFactory(EventEmitter, settings, splits);
+      return readinessManagerFactory(EventEmitter, settings, splits, true);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked
@@ -145,13 +148,9 @@ export function readinessManagerFactory(
     destroy() {
       isDestroyed = true;
       syncLastUpdate();
-
-      segments.removeAllListeners();
-      gate.removeAllListeners();
       clearTimeout(readyTimeoutId);
 
-      if (refCount > 0) refCount--;
-      if (refCount === 0) splits.removeAllListeners();
+      if (!isShared) splits.hasInit = false;
     },
 
     isReady() { return isReady; },

src/readiness/readinessManager.ts

@@ -56,22 +56,18 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
         // Mark the SDK as destroyed immediately
         sdkReadinessManager.readinessManager.destroy();
 
-        // For main client, release the SDK Key and record stat before flushing data
+        // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
         if (!isSharedClient) {
           releaseApiKey(settings.core.authorizationKey);
           telemetryTracker.sessionLength();
+          signalListener && signalListener.stop();
+          uniqueKeysTracker && uniqueKeysTracker.stop();
         }
 
         // Stop background jobs
         syncManager && syncManager.stop();
 
         return __flush().then(() => {
-          // For main client, cleanup event listeners and scheduled jobs
-          if (!isSharedClient) {
-            signalListener && signalListener.stop();
-            uniqueKeysTracker && uniqueKeysTracker.stop();
-          }
-
           // Cleanup storage
           return storage.destroy();
         });

src/sdkClient/sdkClient.ts

@@ -126,6 +126,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     settings,
 
     destroy() {
+      hasInit = false;
       return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
   }, extraProps && extraProps(ctx), lazyInit ? { init } : init());

src/sdkFactory/index.ts

@@ -7,8 +7,6 @@ import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
-import { MySegmentsCacheInMemory } from '../inMemory/MySegmentsCacheInMemory';
-import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
@@ -36,7 +34,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       return InMemoryStorageCSFactory(params);
     }
 
-    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode } } } = params;
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
@@ -55,15 +53,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
       uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
-      destroy() {
-        this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
-        this.segments = new MySegmentsCacheInMemory();
-        this.largeSegments = new MySegmentsCacheInMemory();
-        this.impressions.clear();
-        this.impressionCounts && this.impressionCounts.clear();
-        this.events.clear();
-        this.uniqueKeys?.clear();
-      },
+      destroy() { },
 
       // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
       shared(matchingKey: string) {
@@ -77,11 +67,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
           events: this.events,
           telemetry: this.telemetry,
 
-          destroy() {
-            this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
-            this.segments = new MySegmentsCacheInMemory();
-            this.largeSegments = new MySegmentsCacheInMemory();
-          }
+          destroy() { }
         };
       },
     };

src/storages/inLocalStorage/index.ts

@@ -28,15 +28,7 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
     telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
     uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
 
-    // When using MEMORY we should clean all the caches to leave them empty
-    destroy() {
-      this.splits.clear();
-      this.segments.clear();
-      this.impressions.clear();
-      this.impressionCounts && this.impressionCounts.clear();
-      this.events.clear();
-      this.uniqueKeys && this.uniqueKeys.clear();
-    }
+    destroy() { }
   };
 
   // @TODO revisit storage logic in localhost mode

src/storages/inMemory/InMemoryStorage.ts

@@ -30,16 +30,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
     uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
-    // When using MEMORY we should clean all the caches to leave them empty
-    destroy() {
-      this.splits.clear();
-      this.segments.clear();
-      this.largeSegments.clear();
-      this.impressions.clear();
-      this.impressionCounts && this.impressionCounts.clear();
-      this.events.clear();
-      this.uniqueKeys && this.uniqueKeys.clear();
-    },
+    destroy() { },
 
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
     shared() {
@@ -52,12 +43,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
         events: this.events,
         telemetry: this.telemetry,
 
-        // Set a new splits cache to clean it for the client without affecting other clients
-        destroy() {
-          this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
-          this.segments.clear();
-          this.largeSegments.clear();
-        }
+        destroy() { }
       };
     },
   };

src/storages/inMemory/InMemoryStorageCS.ts

@@ -68,8 +68,8 @@ export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger,
     },
 
     stop() {
-      running = false;
-      if (timeoutID) {
+      if (running) {
+        running = false;
         log.debug(SYNC_TASK_STOP, [taskName]);
         clearTimeout(timeoutID);
         timeoutID = undefined;