@splitsoftware/splitio-commons 1.2.1-rc.8 → 1.3.1-rc.0

package/esm/sdkClient/sdkClient.js

@@ -5,8 +5,8 @@ import { clientInputValidationDecorator } from './clientInputValidation';
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export function sdkClientFactory(params) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, sharedClient = params.sharedClient;
+export function sdkClientFactory(params, isSharedClient) {
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings;
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
@@ -23,7 +23,7 @@ export function sdkClientFactory(params) {
                 sdkReadinessManager.readinessManager.destroy();
                 signalListener && signalListener.stop();
                 // Release the API Key if it is the main client
-                if (!sharedClient)
+                if (!isSharedClient)
                     releaseApiKey(settings.core.authorizationKey);
                 // Cleanup storage
                 return storage.destroy();

package/esm/sdkClient/sdkClientMethodCS.js

@@ -16,12 +16,7 @@ var method = 'Client instantiation';
  */
 export function sdkClientMethodCSFactory(params) {
     var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, readyTimeout = _a.startup.readyTimeout, log = _a.log;
-    // Keeping similar behaviour as in the isomorphic JS SDK: if settings key is invalid,
-    // `false` value is used as binded key of the default client, but trafficType is ignored
-    // @TODO handle as a non-recoverable error
-    var validKey = validateKey(log, key, method);
-    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
-    validKey);
+    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
     // Cache instances created per factory.
@@ -59,9 +54,8 @@ export function sdkClientMethodCSFactory(params) {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined,
-                sharedClient: true
-            })), validKey);
+                signalListener: undefined, // only the main client "destroy" method stops the signal listener
+            }), true), validKey);
             sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
         }

package/esm/sdkClient/sdkClientMethodCSWithTT.js

@@ -18,16 +18,7 @@ var method = 'Client instantiation';
  */
 export function sdkClientMethodCSFactory(params) {
     var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, readyTimeout = _a.startup.readyTimeout, log = _a.log;
-    // Keeping the behaviour as in the isomorphic JS SDK: if settings key or TT are invalid,
-    // `false` value is used as binded key/TT of the default client, which leads to several issues.
-    // @TODO update when supporting non-recoverable errors
-    var validKey = validateKey(log, key, method);
-    var validTrafficType;
-    if (trafficType !== undefined) {
-        validTrafficType = validateTrafficType(log, trafficType, method);
-    }
-    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
-    validKey, validTrafficType);
+    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key, trafficType);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
     // Cache instances created per factory.
@@ -72,9 +63,8 @@ export function sdkClientMethodCSFactory(params) {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined,
-                sharedClient: true
-            })), validKey, validTrafficType);
+                signalListener: undefined, // only the main client "destroy" method stops the signal listener
+            }), true), validKey, validTrafficType);
             sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
         }

package/esm/sdkFactory/index.js

@@ -61,7 +61,8 @@ export function sdkFactory(params) {
     // signal listener
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
     // Sdk client and manager
-    var clientMethod = sdkClientMethodFactory({ eventTracker: eventTracker, impressionsTracker: impressionsTracker, sdkReadinessManager: sdkReadinessManager, settings: settings, storage: storage, syncManager: syncManager, signalListener: signalListener });
+    var ctx = { eventTracker: eventTracker, impressionsTracker: impressionsTracker, sdkReadinessManager: sdkReadinessManager, settings: settings, storage: storage, syncManager: syncManager, signalListener: signalListener };
+    var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
     syncManager && syncManager.start();
     signalListener && signalListener.start();
@@ -78,5 +79,5 @@ export function sdkFactory(params) {
         // Logger wrapper API
         Logger: createLoggerAPI(settings.log),
         settings: settings,
-    }, extraProps && extraProps(settings, syncManager));
+    }, extraProps && extraProps(ctx));
 }

package/esm/services/splitHttpClient.js

@@ -9,25 +9,26 @@ var messageNoFetch = 'Global fetch API is not available.';
  * @param fetch optional http client to use instead of the global Fetch (for environments where Fetch API is not available such as Node)
  */
 export function splitHttpClientFactory(settings, getFetch, getOptions) {
-    var log = settings.log, authorizationKey = settings.core.authorizationKey, version = settings.version, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
+    var log = settings.log;
     var options = getOptions && getOptions();
     var fetch = getFetch && getFetch();
     // if fetch is not available, log Error
     if (!fetch)
         log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
-    var headers = {
-        'Accept': 'application/json',
-        'Content-Type': 'application/json',
-        'Authorization': "Bearer " + authorizationKey,
-        'SplitSDKVersion': version
-    };
-    if (ip)
-        headers['SplitSDKMachineIP'] = ip;
-    if (hostname)
-        headers['SplitSDKMachineName'] = hostname;
     return function httpClient(url, reqOpts, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
+        var authorizationKey = settings.core.authorizationKey, version = settings.version, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
+        var headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': "Bearer " + authorizationKey,
+            'SplitSDKVersion': version
+        };
+        if (ip)
+            headers['SplitSDKMachineIP'] = ip;
+        if (hostname)
+            headers['SplitSDKMachineName'] = hostname;
         var request = objectAssign({
             headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,
             method: reqOpts.method || 'GET',

package/esm/storages/inRedis/RedisAdapter.js

@@ -143,13 +143,19 @@ var RedisAdapter = /** @class */ (function (_super) {
         else { // If it IS the string URL, that'll be the first param for ioredis.
             result.unshift(options.url);
         }
+        if (options.connectionTimeout) {
+            merge(opts, { connectTimeout: options.connectionTimeout });
+        }
+        if (options.tls) {
+            merge(opts, { tls: options.tls });
+        }
         return result;
     };
     /**
      * Parses the options into what we care about.
      */
     RedisAdapter._defineOptions = function (_a) {
-        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass;
+        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass, tls = _a.tls;
         var parsedOptions = {
             connectionTimeout: connectionTimeout,
             operationTimeout: operationTimeout,
@@ -157,7 +163,8 @@ var RedisAdapter = /** @class */ (function (_super) {
             host: host,
             port: port,
             db: db,
-            pass: pass
+            pass: pass,
+            tls: tls
         };
         return merge({}, DEFAULT_OPTIONS, parsedOptions);
     };

package/esm/sync/syncManagerOnline.js

@@ -1,7 +1,7 @@
 import { submitterManagerFactory } from './submitters/submitterManager';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
-import { isConsentGranted } from '../utils/consent';
+import { isConsentGranted } from '../consent';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.

package/esm/trackers/impressionsTracker.js

@@ -18,7 +18,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, integratio
 observer, 
 // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
 countsCache) {
-    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === CONSENT_DECLINED)
@@ -59,7 +59,7 @@ countsCache) {
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
-                        sdkLanguageVersion: version
+                        sdkLanguageVersion: settings.version
                     };
                     // Wrap in a timeout because we don't want it to be blocking.
                     setTimeout(function () {

package/esm/utils/inputValidation/attributes.js

@@ -3,7 +3,7 @@ import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 export function validateAttributes(log, maybeAttrs, method) {
     // Attributes are optional
-    if (isObject(maybeAttrs) || maybeAttrs == undefined) // eslint-disable-line eqeqeq
+    if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq
         return maybeAttrs;
     log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
     return false;

package/esm/utils/lang/index.js

@@ -141,10 +141,12 @@ export function isNaNNumber(val) {
     return val !== val;
 }
 /**
- * Validates if a value is an object with the Object prototype (map object).
+ * Validates if a value is an object created by the Object constructor (plain object).
+ * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
  */
 export function isObject(obj) {
-    return obj !== null && typeof obj === 'object' && obj.constructor === Object;
+    return obj !== null && typeof obj === 'object' && (obj.constructor === Object ||
+        (obj.constructor != null && obj.constructor.name === 'Object'));
 }
 /**
  * Checks if a given value is a string.

package/esm/utils/lang/maps.js

@@ -68,4 +68,17 @@ var MapPoly = /** @class */ (function () {
     return MapPoly;
 }());
 export { MapPoly };
-export var _Map = typeof Map !== 'undefined' ? Map : MapPoly;
+/**
+ * return the Map constructor to use. If native Map is not available or it doesn't support the required features (e.g., IE11),
+ * a ponyfill with minimal features is returned instead.
+ *
+ * Exported for testing purposes only.
+ */
+export function __getMapConstructor() {
+    // eslint-disable-next-line compat/compat
+    if (typeof Array.from === 'function' && typeof Map === 'function' && Map.prototype && Map.prototype.values) {
+        return Map;
+    }
+    return MapPoly;
+}
+export var _Map = __getMapConstructor();

package/esm/utils/settingsValidation/index.js

@@ -3,6 +3,8 @@ import { mode } from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
+import { validateKey } from '../inputValidation/key';
+import { validateTrafficType } from '../inputValidation/trafficType';
 var base = {
     // Define which kind of object you want to retrieve from SplitFactory
     mode: STANDALONE_MODE,
@@ -106,9 +108,25 @@ export function settingsValidation(config, validationParams) {
     // @ts-ignore, modify readonly prop
     if (storage)
         withDefaults.storage = storage(withDefaults);
-    // Although `key` is mandatory according to TS declaration files, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
-    if (withDefaults.mode === LOCALHOST_MODE && withDefaults.core.key === undefined) {
-        withDefaults.core.key = 'localhost_key';
+    // Validate key and TT (for client-side)
+    if (validationParams.acceptKey) {
+        var maybeKey = withDefaults.core.key;
+        // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
+        if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
+            withDefaults.core.key = 'localhost_key';
+        }
+        else {
+            // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
+            // `false` value is used as binded key/TT of the default client, which leads to some issues.
+            // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
+            withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');
+        }
+        if (validationParams.acceptTT) {
+            var maybeTT = withDefaults.core.trafficType;
+            if (maybeTT !== undefined) { // @ts-ignore
+                withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
+            }
+        }
     }
     // Current ip/hostname information
     // @ts-ignore, modify readonly prop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.2.1-rc.8",
+  "version": "1.3.1-rc.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -46,6 +46,18 @@
   "dependencies": {
     "tslib": "^2.3.1"
   },
+  "peerDependencies": {
+    "js-yaml": "^3.13.1",
+    "ioredis": "^4.28.0"
+  },
+  "peerDependenciesMeta": {
+    "js-yaml": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/google.analytics": "0.0.40",
     "@types/ioredis": "^4.28.0",
@@ -62,7 +74,7 @@
     "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
-    "js-yaml": "^3.14.0",
+    "js-yaml": "^3.13.1",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
     "redis-server": "1.2.2",

package/src/{utils/consent.ts → consent/index.ts}

@@ -1,5 +1,5 @@
 import { ISettings } from '../types';
-import { CONSENT_GRANTED } from './constants';
+import { CONSENT_GRANTED } from '../utils/constants';
 
 export function isConsentGranted(settings: ISettings) {
   const userConsent = settings.userConsent;

package/src/consent/sdkUserConsent.ts

@@ -0,0 +1,58 @@
+import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED, USER_CONSENT_INITIAL } from '../logger/constants';
+import { isConsentGranted } from './index';
+import { CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../utils/constants';
+import { isBoolean } from '../utils/lang';
+import { ISdkFactoryContext } from '../sdkFactory/types';
+
+// User consent enum
+const ConsentStatus = {
+  GRANTED: CONSENT_GRANTED,
+  DECLINED: CONSENT_DECLINED,
+  UNKNOWN: CONSENT_UNKNOWN,
+};
+
+/**
+ * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
+ */
+export function createUserConsentAPI(params: ISdkFactoryContext) {
+  const { settings, settings: { log }, syncManager, storage: { events, impressions, impressionCounts } } = params;
+
+  if (!isConsentGranted(settings)) log.info(USER_CONSENT_INITIAL, [settings.userConsent]);
+
+  return {
+    setStatus(consent: unknown) {
+      // validate input param
+      if (!isBoolean(consent)) {
+        log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+        return false;
+      }
+
+      const newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
+
+      if (settings.userConsent !== newConsentStatus) {
+        log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]); // @ts-ignore, modify readonly prop
+        settings.userConsent = newConsentStatus;
+
+        if (consent) { // resumes submitters if transitioning to GRANTED
+          syncManager?.submitter?.start();
+        } else { // pauses submitters and drops tracked data if transitioning to DECLINED
+          syncManager?.submitter?.stop();
+          // @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();
+        }
+      } else {
+        log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
+      }
+
+      return true;
+    },
+
+    getStatus() {
+      return settings.userConsent;
+    },
+
+    Status: ConsentStatus
+  };
+}

package/src/evaluator/parser/index.ts

@@ -31,7 +31,7 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
       const matcher = matcherFactory(log, matcherDto, storage);
 
       // Evaluator function.
-      return (key: string, attributes: SplitIO.Attributes, splitEvaluator: ISplitEvaluator) => {
+      return (key: string, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
         const value = sanitizeValue(log, key, matcherDto, attributes);
         const result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;
 

package/src/evaluator/types.ts

@@ -6,7 +6,7 @@ import { ILogger } from '../logger/types';
 
 export interface IDependencyMatcherValue {
   key: SplitIO.SplitKey,
-  attributes: SplitIO.Attributes
+  attributes?: SplitIO.Attributes
 }
 
 export interface IMatcherDto {
@@ -27,7 +27,7 @@ export interface IEvaluation {
 
 export type IEvaluationResult = IEvaluation & { treatment: string }
 
-export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
+export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
 export type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
 

package/src/evaluator/value/index.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
-function parseValue(log: ILogger, key: string, attributeName: string | null, attributes: SplitIO.Attributes) {
+function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: SplitIO.Attributes) {
   let value = undefined;
   if (attributeName) {
     if (attributes) {
@@ -23,7 +23,7 @@ function parseValue(log: ILogger, key: string, attributeName: string | null, att
 /**
  * Defines value to be matched (key / attribute).
  */
-export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes) {
+export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes) {
   const attributeName = matcherDto.attribute;
   const valueToMatch = parseValue(log, key, attributeName, attributes);
   const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);

package/src/evaluator/value/sanitize.ts

@@ -41,7 +41,7 @@ function sanitizeBoolean(val: any): boolean | undefined {
   return undefined;
 }
 
-function dependencyProcessor(sanitizedValue: string, attributes: SplitIO.Attributes): IDependencyMatcherValue {
+function dependencyProcessor(sanitizedValue: string, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
   return {
     key: sanitizedValue,
     attributes
@@ -69,7 +69,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes) {
+export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes) {
   const processor = getProcessingFunction(matcherTypeID, dataType);
   let sanitizedValue: string | number | boolean | Array<string | number> | IDependencyMatcherValue | undefined;
 

package/src/integrations/pluggable.ts

@@ -29,10 +29,10 @@ export function pluggableIntegrationsManagerFactory(
 
   // Exception safe methods: each integration module is responsable for handling errors
   return {
-    handleImpression: function (impressionData: SplitIO.ImpressionData) {
+    handleImpression(impressionData: SplitIO.ImpressionData) {
       listeners.forEach(listener => listener.queue({ type: SPLIT_IMPRESSION, payload: impressionData }));
     },
-    handleEvent: function (eventData: SplitIO.EventData) {
+    handleEvent(eventData: SplitIO.EventData) {
       listeners.forEach(listener => listener.queue({ type: SPLIT_EVENT, payload: eventData }));
     }
   };

package/src/listeners/browser.ts

@@ -11,7 +11,7 @@ import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
-import { isConsentGranted } from '../utils/consent';
+import { isConsentGranted } from '../consent';
 
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 const UNLOAD_DOM_EVENT = 'unload';

package/src/logger/constants.ts

@@ -70,6 +70,7 @@ export const EVENTS_TRACKER_SUCCESS = 120;
 export const IMPRESSIONS_TRACKER_SUCCESS = 121;
 export const USER_CONSENT_UPDATED = 122;
 export const USER_CONSENT_NOT_UPDATED = 123;
+export const USER_CONSENT_INITIAL = 124;
 
 export const ENGINE_VALUE_INVALID = 200;
 export const ENGINE_VALUE_NO_ATTRIBUTES = 201;

package/src/logger/messages/info.ts

@@ -16,6 +16,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(s).'],
   [c.USER_CONSENT_UPDATED, 'setUserConsent: consent status changed from %s to %s.'],
   [c.USER_CONSENT_NOT_UPDATED, 'setUserConsent: call had no effect because it was the current consent status (%s).'],
+  [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],
 
   // synchronizer
   [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],

package/src/readiness/sdkReadinessManager.ts

@@ -51,7 +51,7 @@ export function sdkReadinessManagerFactory(
 
   // default onRejected handler, that just logs the error, if ready promise doesn't have one.
   function defaultOnRejected(err: any) {
-    log.error(err);
+    log.error(err && err.message);
   }
 
   function generateReadyPromise() {
@@ -62,7 +62,9 @@ export function sdkReadinessManagerFactory(
         if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled()) log.warn(CLIENT_NO_LISTENER);
         resolve();
       });
-      readinessManager.gate.once(SDK_READY_TIMED_OUT, reject);
+      readinessManager.gate.once(SDK_READY_TIMED_OUT, (message: string) => {
+        reject(new Error(message));
+      });
     }), defaultOnRejected);
 
     return promise;
@@ -106,10 +108,10 @@ export function sdkReadinessManagerFactory(
          * @function ready
          * @returns {Promise<void>}
          */
-        ready: () => {
+        ready() {
           if (readinessManager.hasTimedout()) {
             if (!readinessManager.isReady()) {
-              return promiseWrapper(Promise.reject('Split SDK has emitted SDK_READY_TIMED_OUT event.'), defaultOnRejected);
+              return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
             } else {
               return Promise.resolve();
             }
@@ -118,7 +120,7 @@ export function sdkReadinessManagerFactory(
         },
 
         // Expose status for internal purposes only. Not considered part of the public API, and might be updated eventually.
-        __getStatus: () => {
+        __getStatus() {
           return {
             isReady: readinessManager.isReady(),
             isReadyFromCache: readinessManager.isReadyFromCache(),

package/src/sdkClient/client.ts

@@ -5,17 +5,16 @@ import { validateSplitExistance } from '../utils/inputValidation/splitExistance'
 import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
-import { IClientFactoryParams } from './types';
 import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
-
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
  * Creator of base client with getTreatments and track methods.
  */
 // @TODO missing time tracking to collect telemetry
-export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
+export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker } = params;
   const { log, mode } = settings;
 
@@ -125,6 +124,6 @@ export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | S
     getTreatments,
     getTreatmentsWithConfig,
     track,
-    isBrowserClient: false
+    isClientSide: false
   } as SplitIO.IClient | SplitIO.IAsyncClient;
 }

package/src/sdkClient/clientCS.ts

@@ -25,6 +25,6 @@ export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: Sp
     // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
     track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
 
-    isBrowserClient: true
+    isClientSide: true
   }) as SplitIO.ICsClient;
 }

package/src/sdkClient/sdkClient.ts

@@ -3,13 +3,13 @@ import { IStatusInterface, SplitIO } from '../types';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
-import { ISdkClientFactoryParams } from './types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager, syncManager, storage, signalListener, settings, sharedClient } = params;
+export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
+  const { sdkReadinessManager, syncManager, storage, signalListener, settings } = params;
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -35,7 +35,7 @@ export function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClie
           signalListener && signalListener.stop();
 
           // Release the API Key if it is the main client
-          if (!sharedClient) releaseApiKey(settings.core.authorizationKey);
+          if (!isSharedClient) releaseApiKey(settings.core.authorizationKey);
 
           // Cleanup storage
           return storage.destroy();

package/src/sdkClient/sdkClientMethod.ts

@@ -1,12 +1,12 @@
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
 import { sdkClientFactory } from './sdkClient';
 import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
  * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
-export function sdkClientMethodFactory(params: ISdkClientFactoryParams): () => SplitIO.IClient | SplitIO.IAsyncClient {
+export function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient {
   const log = params.settings.log;
   const clientInstance = sdkClientFactory(params);