@splitsoftware/splitio-commons 1.6.2-rc.0 → 1.6.2-rc.10

package/esm/utils/constants/index.js

@@ -13,6 +13,7 @@ export var SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export var DEBUG = 'DEBUG';
 export var OPTIMIZED = 'OPTIMIZED';
+export var NONE = 'NONE';
 // SDK Modes
 export var LOCALHOST_MODE = 'localhost';
 export var STANDALONE_MODE = 'standalone';
@@ -37,6 +38,7 @@ export var CONSUMER_ENUM = 1;
 export var CONSUMER_PARTIAL_ENUM = 2;
 export var OPTIMIZED_ENUM = 0;
 export var DEBUG_ENUM = 1;
+export var NONE_ENUM = 2;
 export var SPLITS = 'sp';
 export var IMPRESSIONS = 'im';
 export var IMPRESSIONS_COUNT = 'ic';

package/esm/utils/lang/maps.js

@@ -37,13 +37,6 @@ var MapPoly = /** @class */ (function () {
         this.__mapKeysData__.length = 0;
         this.__mapValuesData__.length = 0;
     };
-    MapPoly.prototype.set = function (key, value) {
-        var index = this.__mapKeysData__.indexOf(key);
-        if (index === -1)
-            index = this.__mapKeysData__.push(key) - 1;
-        this.__mapValuesData__[index] = value;
-        return this;
-    };
     MapPoly.prototype.delete = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
@@ -52,12 +45,27 @@ var MapPoly = /** @class */ (function () {
         this.__mapValuesData__.splice(index, 1);
         return true;
     };
+    MapPoly.prototype.forEach = function (callbackfn, thisArg) {
+        for (var i = 0; i < this.__mapKeysData__.length; i++) {
+            callbackfn.call(thisArg, this.__mapValuesData__[i], this.__mapKeysData__[i], this);
+        }
+    };
     MapPoly.prototype.get = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
             return;
         return this.__mapValuesData__[index];
     };
+    MapPoly.prototype.has = function (key) {
+        return this.__mapKeysData__.indexOf(key) !== -1;
+    };
+    MapPoly.prototype.set = function (key, value) {
+        var index = this.__mapKeysData__.indexOf(key);
+        if (index === -1)
+            index = this.__mapKeysData__.push(key) - 1;
+        this.__mapValuesData__[index] = value;
+        return this;
+    };
     Object.defineProperty(MapPoly.prototype, "size", {
         get: function () {
             return this.__mapKeysData__.length;

package/esm/utils/redis/RedisMock.js

@@ -0,0 +1,28 @@
+//@ts-nocheck
+function identityFunction(data) {
+    return data;
+}
+function asyncFunction(data) {
+    return Promise.resolve(data);
+}
+var IDENTITY_METHODS = [];
+var ASYNC_METHODS = ['rpush', 'hincrby'];
+var PIPELINE_METHODS = ['rpush', 'hincrby'];
+var RedisMock = /** @class */ (function () {
+    function RedisMock() {
+        var _this = this;
+        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
+        IDENTITY_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(identityFunction);
+        });
+        ASYNC_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(asyncFunction);
+        });
+        PIPELINE_METHODS.forEach(function (method) {
+            _this.pipelineMethods[method] = _this[method];
+        });
+        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
+    }
+    return RedisMock;
+}());
+export { RedisMock };

package/esm/utils/settingsValidation/impressionsMode.js

@@ -1,10 +1,10 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { DEBUG, OPTIMIZED } from '../constants';
+import { DEBUG, OPTIMIZED, NONE } from '../constants';
 import { stringToUpperCase } from '../lang';
 export function validImpressionsMode(log, impressionsMode) {
     impressionsMode = stringToUpperCase(impressionsMode);
-    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1)
+    if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1)
         return impressionsMode;
-    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
     return OPTIMIZED;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.0",
+  "version": "1.6.2-rc.10",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -70,7 +70,6 @@
     "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
-    "js-yaml": "^3.13.1",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
     "redis-server": "1.2.2",

package/src/consent/sdkUserConsent.ts

@@ -40,8 +40,8 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
 
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear();
-          if (impressionCounts) impressionCounts.clear();
+          if (impressions.clear) impressions.clear();// @ts-ignore
+          if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
         }
       } else {
         log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);

package/src/evaluator/index.ts

@@ -29,19 +29,19 @@ export function evaluateFeature(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
-  let stringifiedSplit;
+  let parsedSplit;
 
   try {
-    stringifiedSplit = storage.splits.getSplit(splitName);
+    parsedSplit = storage.splits.getSplit(splitName);
   } catch (e) {
     // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentException;
   }
 
-  if (thenable(stringifiedSplit)) {
-    return stringifiedSplit.then((result) => getEvaluation(
+  if (thenable(parsedSplit)) {
+    return parsedSplit.then((split) => getEvaluation(
       log,
-      result,
+      split,
       key,
       attributes,
       storage,
@@ -54,7 +54,7 @@ export function evaluateFeature(
 
   return getEvaluation(
     log,
-    stringifiedSplit,
+    parsedSplit,
     key,
     attributes,
     storage,
@@ -68,28 +68,28 @@ export function evaluateFeatures(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
-  let stringifiedSplits;
+  let parsedSplits;
 
   try {
-    stringifiedSplits = storage.splits.getSplits(splitNames);
+    parsedSplits = storage.splits.getSplits(splitNames);
   } catch (e) {
     // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentsException(splitNames);
   }
 
-  return (thenable(stringifiedSplits)) ?
-    stringifiedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
+  return thenable(parsedSplits) ?
+    parsedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
       .catch(() => {
         // Exception on async `getSplits` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         return treatmentsException(splitNames);
       }) :
-    getEvaluations(log, splitNames, stringifiedSplits, key, attributes, storage);
+    getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 
 function getEvaluation(
   log: ILogger,
-  stringifiedSplit: string | null,
+  splitJSON: ISplit | null,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
@@ -100,8 +100,7 @@ function getEvaluation(
     config: null
   };
 
-  if (stringifiedSplit) {
-    const splitJSON: ISplit = JSON.parse(stringifiedSplit);
+  if (splitJSON) {
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
@@ -125,7 +124,7 @@ function getEvaluation(
 function getEvaluations(
   log: ILogger,
   splitNames: string[],
-  splits: Record<string, string | null>,
+  splits: Record<string, ISplit | null>,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,

package/src/integrations/ga/GaToSplit.ts

@@ -12,6 +12,7 @@ import { SplitIO } from '../../types';
 import { Identity, GoogleAnalyticsToSplitOptions } from './types';
 import { ILogger } from '../../logger/types';
 import { IIntegrationFactoryParams } from '../types';
+import { ITelemetryTracker } from '../../trackers/types';
 
 const logPrefix = 'ga-to-split: ';
 const logNameMapper = 'ga-to-split:mapper';
@@ -25,7 +26,7 @@ const logNameMapper = 'ga-to-split:mapper';
  * @param log Logger instance.
  * @param autoRequire If true, log error when auto-require script is not detected
  */
-function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire?: boolean) {
+function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire: boolean, telemetryTracker?: ITelemetryTracker) {
   // get reference to global command queue. Init it if not defined yet.
   const gaAlias = window.GoogleAnalyticsObject || 'ga';
   window[gaAlias] = window[gaAlias] || function () {
@@ -35,10 +36,13 @@ function providePlugin(window: any, pluginName: string, pluginConstructor: Funct
   // provides the plugin for use with analytics.js.
   window[gaAlias]('provide', pluginName, pluginConstructor);
 
-  if (autoRequire && (!window[gaAlias].q || window[gaAlias].q.push === [].push)) {
-    // Expecting spy on ga.q push method but not found
+  const hasAutoRequire = window[gaAlias].q && window[gaAlias].q.push !== [].push;
+  if (autoRequire && !hasAutoRequire) { // Expecting spy on ga.q push method but not found
     log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
   }
+  if (telemetryTracker && hasAutoRequire) {
+    telemetryTracker.addTag('integration:ga-autorequire');
+  }
 }
 
 // Default mapping: object used for building the default mapper from hits to Split events
@@ -191,7 +195,7 @@ export function fixEventTypeId(log: ILogger, eventTypeId: any) {
  */
 export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIntegrationFactoryParams) {
 
-  const { storage, settings: { core: coreSettings, log } } = params;
+  const { storage, settings: { core: coreSettings, log }, telemetryTracker } = params;
 
   const defaultOptions = {
     prefix: defaultPrefix,
@@ -291,5 +295,5 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
   }
 
   // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true);
+  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);
 }

package/src/integrations/types.ts

@@ -1,5 +1,5 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
 import { ISettings, SplitIO } from '../types';
 
 export interface IIntegration {
@@ -11,6 +11,7 @@ export type IIntegrationManager = IEventsHandler & IImpressionsHandler;
 export interface IIntegrationFactoryParams {
   storage: { events: IEventsCacheBase }
   settings: ISettings
+  telemetryTracker: ITelemetryTracker
 }
 
 export type IntegrationFactory = {

package/src/listeners/browser.ts

@@ -7,7 +7,7 @@ import { fromImpressionCountsCollector } from '../sync/submitters/impressionCoun
 import { IResponse, ISplitApi } from '../services/types';
 import { ImpressionDTO, ISettings } from '../types';
 import { ImpressionsPayload } from '../sync/submitters/types';
-import { OPTIMIZED, DEBUG } from '../utils/constants';
+import { OPTIMIZED, DEBUG, NONE } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
@@ -88,9 +88,10 @@ export class BrowserSignalListener implements ISignalListener {
     // Flush impressions & events data if there is user consent
     if (isConsentGranted(this.settings)) {
       const eventsUrl = this.settings.urls.events;
+      const sim = this.settings.sync.impressionsMode;
       const extraMetadata = {
         // sim stands for Sync/Split Impressions Mode
-        sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
+        sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE
       };
 
       this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);

package/src/logger/constants.ts

@@ -143,4 +143,5 @@ export const LOG_PREFIX_SYNC_POLLING = LOG_PREFIX_SYNC + ':polling-manager: ';
 export const LOG_PREFIX_SYNC_SUBMITTERS = LOG_PREFIX_SYNC + ':submitter: ';
 export const LOG_PREFIX_IMPRESSIONS_TRACKER = 'impressions-tracker: ';
 export const LOG_PREFIX_EVENTS_TRACKER = 'events-tracker: ';
+export const LOG_PREFIX_UNIQUE_KEYS_TRACKER = 'unique-keys-tracker: ';
 export const LOG_PREFIX_CLEANUP = 'cleanup: ';

package/src/sdkClient/client.ts

@@ -9,6 +9,17 @@ import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
+
+const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
+
+function treatmentsNotReady(splitNames: string[]) {
+  const evaluations: Record<string, IEvaluationResult> = {};
+  splitNames.forEach(splitName => {
+    evaluations[splitName] = treatmentNotReady;
+  });
+  return evaluations;
+}
 
 /**
  * Creator of base client with getTreatments and track methods.
@@ -29,7 +40,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatment;
     };
 
-    const evaluation = evaluateFeature(log, key, splitName, attributes, storage);
+    const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+      evaluateFeature(log, key, splitName, attributes, storage) :
+      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+        treatmentNotReady :
+        Promise.resolve(treatmentNotReady); // Promisify if async
 
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
@@ -53,7 +68,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatments;
     };
 
-    const evaluations = evaluateFeatures(log, key, splitNames, attributes, storage);
+    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+      evaluateFeatures(log, key, splitNames, attributes, storage) :
+      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+        treatmentsNotReady(splitNames) :
+        Promise.resolve(treatmentsNotReady(splitNames)); // Promisify if async
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
@@ -72,15 +91,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     invokingMethodName: string,
     queue: ImpressionDTO[]
   ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
-    const isSdkReady = readinessManager.isReady() || readinessManager.isReadyFromCache();
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
 
-    // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
-    if (!isSdkReady) {
-      evaluation = { treatment: CONTROL, label: SDK_NOT_READY };
-    }
-
     const { treatment, label, changeNumber, config = null } = evaluation;
     log.info(IMPRESSION, [splitName, matchingKey, treatment, label]);
 

package/src/sdkClient/sdkClient.ts

@@ -9,7 +9,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker } = params;
+  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker, uniqueKeysTracker } = params;
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -39,6 +39,8 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
 
           // Release the API Key if it is the main client
           if (!isSharedClient) releaseApiKey(settings.core.authorizationKey);
+          
+          if (uniqueKeysTracker) uniqueKeysTracker.stop();
 
           // Cleanup storage
           return storage.destroy();

package/src/sdkFactory/index.ts

@@ -13,6 +13,11 @@ import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
+import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
+import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
+import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
+import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
+import { NONE, OPTIMIZED } from '../utils/constants';
 
 /**
  * Modular SDK factory
@@ -21,7 +26,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
-    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory } = params;
+    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
+    filterAdapterFactory } = params;
   const log = settings.log;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
@@ -45,6 +51,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
     // ATM, only used by PluggableStorage
     mode: settings.mode,
+    impressionsMode: settings.sync.impressionsMode,
 
     // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined,
     // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
@@ -60,18 +67,31 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const storage = storageFactory(storageFactoryParams);
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
-  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
-
-  // trackers
-  const observer = impressionsObserverFactory && impressionsObserverFactory();
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
+  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
+
+  const observer = impressionsObserverFactory();
+  const uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
+
+  let strategy;
+  switch (storageFactoryParams.impressionsMode) {
+    case OPTIMIZED:
+      strategy = strategyOptimizedFactory(observer, storage.impressionCounts!);
+      break;
+    case NONE:
+      strategy = strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!);
+      break;
+    default:
+      strategy = strategyDebugFactory(observer);
+  }
+
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform };
+  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;

package/src/sdkFactory/types.ts

@@ -6,7 +6,7 @@ import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 
 /**
@@ -44,6 +44,7 @@ export interface ISdkFactoryContext {
   eventTracker: IEventTracker,
   telemetryTracker: ITelemetryTracker,
   storage: IStorageSync | IStorageAsync,
+  uniqueKeysTracker?: IUniqueKeysTracker,
   signalListener?: ISignalListener
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
@@ -96,6 +97,11 @@ export interface ISdkFactoryParams {
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
   sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
 
+  // Impression observer factory. If provided, will be used for impressions dedupe
+  impressionsObserverFactory: () => IImpressionObserver
+  
+  filterAdapterFactory?: () => IFilterAdapter
+
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
   // Pass only if `syncManager` (used by Node listener) and `splitApi` (used by Browser listener) are passed.
   SignalListener?: new (
@@ -107,9 +113,6 @@ export interface ISdkFactoryParams {
   // @TODO review impressionListener and integrations interfaces. What about handling impressionListener as an integration ?
   integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined,
 
-  // Impression observer factory. If provided, will be used for impressions dedupe
-  impressionsObserverFactory?: () => IImpressionObserver
-
   // Optional function to assign additional properties to the factory instance
   extraProps?: (params: ISdkFactoryContext) => object
 }

package/src/sdkManager/index.ts

@@ -18,16 +18,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(v => v.treatment) : [];
 }
 
-function objectToView(json: string | null): SplitIO.SplitView | null {
-  let splitObject: ISplit | null;
-
-  try {
-    // @ts-expect-error
-    splitObject = JSON.parse(json);
-  } catch (e) {
-    return null;
-  }
-
+function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
   if (!splitObject) return null;
 
   return {
@@ -40,10 +31,10 @@ function objectToView(json: string | null): SplitIO.SplitView | null {
   };
 }
 
-function objectsToViews(jsons: string[]) {
+function objectsToViews(splitObjects: ISplit[]) {
   let views: SplitIO.SplitView[] = [];
 
-  jsons.forEach(split => {
+  splitObjects.forEach(split => {
     const view = objectToView(split);
     if (view) views.push(view);
   });

package/src/services/splitApi.ts

@@ -106,15 +106,37 @@ export function splitApiFactory(
       const url = `${urls.events}/testImpressions/count`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
     },
+    
+    /**
+     * Post unique keys for client side.
+     *
+     * @param body  unique keys payload
+     * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
+     */
+    postUniqueKeysBulkCs(body: string, headers?: Record<string, string>) {
+      const url = `${urls.telemetry}/v1/keys/cs`;
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
+    },
+    
+    /**
+     * Post unique keys for server side.
+     *
+     * @param body  unique keys payload
+     * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
+     */
+    postUniqueKeysBulkSs(body: string, headers?: Record<string, string>) {
+      const url = `${urls.telemetry}/v1/keys/ss`;
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
+    },
 
-    postMetricsConfig(body: string) {
+    postMetricsConfig(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/v1/metrics/config`;
-      return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
     },
 
-    postMetricsUsage(body: string) {
+    postMetricsUsage(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/v1/metrics/usage`;
-      return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
     }
   };
 }

package/src/services/types.ts

@@ -43,13 +43,17 @@ export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => P
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
+export type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
+
+export type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
+
 export type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
 export type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostMetricsConfig = (body: string) => Promise<IResponse>
+export type IPostMetricsConfig = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostMetricsUsage = (body: string) => Promise<IResponse>
+export type IPostMetricsUsage = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
 export interface ISplitApi {
 	getSdkAPIHealthCheck: IHealthCheckAPI
@@ -59,6 +63,8 @@ export interface ISplitApi {
 	fetchSegmentChanges: IFetchSegmentChanges
 	fetchMySegments: IFetchMySegments
 	postEventsBulk: IPostEventsBulk
+	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
+	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs
 	postTestImpressionsBulk: IPostTestImpressionsBulk
 	postTestImpressionsCount: IPostTestImpressionsCount
 	postMetricsConfig: IPostMetricsConfig