@splitsoftware/splitio-commons 2.4.2-rc.3 → 11.5.0-rc.0

package/src/sdkClient/clientAttributesDecoration.ts

@@ -1,139 +0,0 @@
-import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
-import { validateAttributesDeep } from '../utils/inputValidation/attributes';
-import SplitIO from '../../types/splitio';
-import { ILogger } from '../logger/types';
-import { objectAssign } from '../utils/lang/objectAssign';
-
-/**
- * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
- */
-export function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient) {
-
-  const attributeStorage = new AttributesCacheInMemory();
-
-  // Keep a reference to the original methods
-  const clientGetTreatment = client.getTreatment;
-  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-  const clientGetTreatments = client.getTreatments;
-  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
-  const clientGetTreatmentsByFlagSets = client.getTreatmentsByFlagSets;
-  const clientGetTreatmentsWithConfigByFlagSets = client.getTreatmentsWithConfigByFlagSets;
-  const clientGetTreatmentsByFlagSet = client.getTreatmentsByFlagSet;
-  const clientGetTreatmentsWithConfigByFlagSet = client.getTreatmentsWithConfigByFlagSet;
-
-  function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    return clientGetTreatment(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes), maybeOptions);
-  }
-
-  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    return clientGetTreatmentWithConfig(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes), maybeOptions);
-  }
-
-  function getTreatments(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    return clientGetTreatments(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes), maybeOptions);
-  }
-
-  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes), maybeOptions);
-  }
-
-  function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes), maybeOptions);
-  }
-
-  function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes), maybeOptions);
-  }
-
-  function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes), maybeOptions);
-  }
-
-  function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes), maybeOptions);
-  }
-
-  function combineAttributes(maybeAttributes: SplitIO.Attributes | undefined): SplitIO.Attributes | undefined {
-    const storedAttributes = attributeStorage.getAll();
-    return Object.keys(storedAttributes).length > 0 ?
-      objectAssign({}, storedAttributes, maybeAttributes) :
-      maybeAttributes;
-  }
-
-  return objectAssign(client, {
-    getTreatment: getTreatment,
-    getTreatmentWithConfig: getTreatmentWithConfig,
-    getTreatments: getTreatments,
-    getTreatmentsWithConfig: getTreatmentsWithConfig,
-    getTreatmentsByFlagSets: getTreatmentsByFlagSets,
-    getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
-    getTreatmentsByFlagSet: getTreatmentsByFlagSet,
-    getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-
-    /**
-     * Add an attribute to client's in memory attributes storage
-     *
-     * @param attributeName - Attribute name
-     * @param attributeValue - Attribute value
-     * @returns true if the attribute was stored and false otherways
-     */
-    setAttribute(attributeName: string, attributeValue: SplitIO.AttributeType) {
-      const attribute: Record<string, Object> = {};
-      attribute[attributeName] = attributeValue;
-      if (!validateAttributesDeep(log, attribute, 'setAttribute')) return false;
-      log.debug(`stored ${attributeValue} for attribute ${attributeName}`);
-      return attributeStorage.setAttribute(attributeName, attributeValue);
-    },
-
-    /**
-     * Returns the attribute with the given name
-     *
-     * @param attributeName - Attribute name
-     * @returns Attribute with the given name
-     */
-    getAttribute(attributeName: string) {
-      log.debug(`retrieved attribute ${attributeName}`);
-      return attributeStorage.getAttribute(attributeName + '');
-    },
-
-    /**
-     * Add to client's in memory attributes storage the attributes in 'attributes'
-     *
-     * @param attributes - Object with attributes to store
-     * @returns true if attributes were stored an false otherways
-     */
-    setAttributes(attributes: Record<string, Object>) {
-      if (!validateAttributesDeep(log, attributes, 'setAttributes')) return false;
-      return attributeStorage.setAttributes(attributes);
-    },
-
-    /**
-     * Return all the attributes stored in client's in memory attributes storage
-     *
-     * @returns returns all the stored attributes
-     */
-    getAttributes() {
-      return attributeStorage.getAll();
-    },
-
-    /**
-     * Removes from client's in memory attributes storage the attribute with the given name
-     *
-     * @param attributeName - Attribute name
-     * @returns true if attribute was removed and false otherways
-     */
-    removeAttribute(attributeName: string) {
-      log.debug(`removed attribute ${attributeName}`);
-      return attributeStorage.removeAttribute(attributeName + '');
-    },
-
-    /**
-     * Remove all the stored attributes in the client's in memory attribute storage
-     */
-    clearAttributes() {
-      return attributeStorage.clear();
-    }
-
-  });
-
-}

package/src/sdkClient/clientCS.ts

@@ -1,34 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { ILogger } from '../logger/types';
-import SplitIO from '../../types/splitio';
-import { clientAttributesDecoration } from './clientAttributesDecoration';
-
-
-/**
- * Decorator that binds a key to client methods
- *
- * @param client - sync client instance
- * @param key - validated split key
- */
-export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey): SplitIO.IBrowserClient {
-
-  let clientCS = clientAttributesDecoration(log, client);
-
-  return objectAssign(clientCS, {
-    // In the client-side API, we bind a key to the client `getTreatment*` and `track` methods
-    getTreatment: clientCS.getTreatment.bind(clientCS, key),
-    getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
-    getTreatments: clientCS.getTreatments.bind(clientCS, key),
-    getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
-    getTreatmentsByFlagSets: clientCS.getTreatmentsByFlagSets.bind(clientCS, key),
-    getTreatmentsWithConfigByFlagSets: clientCS.getTreatmentsWithConfigByFlagSets.bind(clientCS, key),
-    getTreatmentsByFlagSet: clientCS.getTreatmentsByFlagSet.bind(clientCS, key),
-    getTreatmentsWithConfigByFlagSet: clientCS.getTreatmentsWithConfigByFlagSet.bind(clientCS, key),
-
-    track: clientCS.track.bind(clientCS, key),
-
-    // Not part of the public API. These properties are used to support other modules (e.g., Split Suite)
-    isClientSide: true,
-    key
-  }) as SplitIO.IBrowserClient;
-}

package/src/sdkClient/clientInputValidation.ts

@@ -1,178 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import {
-  validateAttributes,
-  validateEvent,
-  validateEventValue,
-  validateEventProperties,
-  validateKey,
-  validateSplit,
-  validateSplits,
-  validateTrafficType,
-  validateIfNotDestroyed,
-  validateIfOperational,
-  validateEvaluationOptions
-} from '../utils/inputValidation';
-import { startsWith } from '../utils/lang';
-import { CONTROL, CONTROL_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
-import { IReadinessManager } from '../readiness/types';
-import { MaybeThenable } from '../dtos/types';
-import { ISettings } from '../types';
-import SplitIO from '../../types/splitio';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
-import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
-
-/**
- * Decorator that validates the input before actually executing the client methods.
- * We should "guard" the client here, while not polluting the "real" implementation of those methods.
- */
-export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient {
-
-  const { log, mode } = settings;
-  const isAsync = isConsumerMode(mode);
-
-  /**
-   * Avoid repeating this validations code
-   */
-  function validateEvaluationParams(methodName: string, maybeKey: SplitIO.SplitKey, maybeNameOrNames: string | string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const key = validateKey(log, maybeKey, methodName);
-
-    const nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
-      validateFlagSets(log, methodName, maybeNameOrNames as string[], settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
-      startsWith(methodName, GET_TREATMENTS) ?
-        validateSplits(log, maybeNameOrNames, methodName) :
-        validateSplit(log, maybeNameOrNames, methodName);
-
-    const attributes = validateAttributes(log, maybeAttributes, methodName);
-    const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
-    const options = validateEvaluationOptions(log, maybeOptions, methodName);
-
-    validateIfOperational(log, readinessManager, methodName, nameOrNames);
-
-    const valid = isNotDestroyed && key && nameOrNames && attributes !== false;
-
-    return {
-      valid,
-      key,
-      nameOrNames,
-      attributes,
-      options
-    };
-  }
-
-  function wrapResult<T>(value: T): MaybeThenable<T> {
-    return isAsync ? Promise.resolve(value) : value;
-  }
-
-  function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const params = validateEvaluationParams(GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
-
-    if (params.valid) {
-      return client.getTreatment(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult(CONTROL);
-    }
-  }
-
-  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const params = validateEvaluationParams(GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
-
-    if (params.valid) {
-      return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));
-    }
-  }
-
-  function getTreatments(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const params = validateEvaluationParams(GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
-
-    if (params.valid) {
-      return client.getTreatments(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const res: SplitIO.Treatments = {};
-      if (params.nameOrNames) (params.nameOrNames as string[]).forEach((split: string) => res[split] = CONTROL);
-
-      return wrapResult(res);
-    }
-  }
-
-  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
-
-    if (params.valid) {
-      return client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      const res: SplitIO.TreatmentsWithConfig = {};
-      if (params.nameOrNames) (params.nameOrNames as string[]).forEach(split => res[split] = objectAssign({}, CONTROL_WITH_CONFIG));
-
-      return wrapResult(res);
-    }
-  }
-
-  function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
-
-    if (params.valid) {
-      return client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
-
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.nameOrNames as string[], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
-
-    if (params.valid) {
-      return client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes, maybeOptions?: SplitIO.EvaluationOptions) {
-    const params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
-
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, (params.nameOrNames as string[])[0], params.attributes as SplitIO.Attributes | undefined, params.options);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
-    const key = validateKey(log, maybeKey, TRACK_FN_LABEL);
-    const tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
-    const event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
-    const eventValue = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
-    const { properties, size } = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL);
-    const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
-
-    if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
-      return client.track(key, tt, event, eventValue, properties, size);
-    } else {
-      return isAsync ? Promise.resolve(false) : false;
-    }
-  }
-
-  return {
-    getTreatment,
-    getTreatmentWithConfig,
-    getTreatments,
-    getTreatmentsWithConfig,
-    getTreatmentsByFlagSets,
-    getTreatmentsWithConfigByFlagSets,
-    getTreatmentsByFlagSet,
-    getTreatmentsWithConfigByFlagSet,
-    track
-  } as TClient;
-}

package/src/sdkClient/identity.ts

@@ -1,5 +0,0 @@
-import SplitIO from '../../types/splitio';
-
-export function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) { // @ts-ignore
-  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType ? trafficType : ''}`;
-}

package/src/sdkClient/sdkClient.ts

@@ -1,77 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import SplitIO from '../../types/splitio';
-import { releaseApiKey } from '../utils/inputValidation/apiKey';
-import { clientFactory } from './client';
-import { clientInputValidationDecorator } from './clientInputValidation';
-import { ISdkFactoryContext } from '../sdkFactory/types';
-
-const COOLDOWN_TIME_IN_MILLIS = 1000;
-
-/**
- * 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, uniqueKeysTracker } = params;
-
-  let lastActionTime = 0;
-
-  function __cooldown(func: Function, time: number) {
-    const now = Date.now();
-    //get the actual time elapsed in ms
-    const timeElapsed = now - lastActionTime;
-    //check if the time elapsed is less than desired cooldown
-    if (timeElapsed < time) {
-      //if yes, return message with remaining time in seconds
-      settings.log.warn(`Flush cooldown, remaining time ${(time - timeElapsed) / 1000} seconds`);
-      return Promise.resolve();
-    } else {
-      //Do the requested action and re-assign the lastActionTime
-      lastActionTime = now;
-      return func();
-    }
-  }
-
-  function __flush() {
-    return syncManager ? syncManager.flush() : Promise.resolve();
-  }
-
-  return objectAssign(
-    // Proto-linkage of the readiness Event Emitter
-    Object.create(sdkReadinessManager.sdkStatus) as SplitIO.IStatusInterface,
-
-    // Client API (getTreatment* & track methods)
-    clientInputValidationDecorator(
-      settings,
-      clientFactory(params),
-      sdkReadinessManager.readinessManager
-    ),
-
-    // Sdk destroy
-    {
-      flush() {
-        // @TODO define cooldown time
-        return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
-      },
-      destroy() {
-        // Mark the SDK as destroyed immediately
-        sdkReadinessManager.readinessManager.destroy();
-
-        // 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.stop();
-        }
-
-        // Stop background jobs
-        syncManager && syncManager.stop();
-
-        return __flush().then(() => {
-          // Cleanup storage
-          return storage.destroy();
-        });
-      }
-    }
-  );
-}

package/src/sdkClient/sdkClientMethod.ts

@@ -1,24 +0,0 @@
-import SplitIO from '../../types/splitio';
-import { sdkClientFactory } from './sdkClient';
-import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
-import { ISdkFactoryContext } from '../sdkFactory/types';
-
-/**
- * Factory of client method for server-side SDKs
- */
-export function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient {
-  const log = params.settings.log;
-  const clientInstance = sdkClientFactory(params);
-
-  // Only one client in server-side without bound key
-  params.clients[''] = clientInstance;
-
-  return function client() {
-    if (arguments.length > 0) {
-      throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');
-    }
-
-    log.debug(RETRIEVE_CLIENT_DEFAULT);
-    return clientInstance;
-  };
-}

package/src/sdkClient/sdkClientMethodCS.ts

@@ -1,85 +0,0 @@
-import { clientCSDecorator } from './clientCS';
-import SplitIO from '../../types/splitio';
-import { validateKey } from '../utils/inputValidation/key';
-import { getMatching, keyParser } from '../utils/key';
-import { sdkClientFactory } from './sdkClient';
-import { ISyncManagerCS } from '../sync/types';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
-import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
-import { ISdkFactoryContext } from '../sdkFactory/types';
-import { buildInstanceId } from './identity';
-
-/**
- * Factory of client method for the client-side API variant where TT is ignored.
- * Therefore, clients don't have a bound TT for the track method.
- */
-export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.IBrowserClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
-
-  const mainClientInstance = clientCSDecorator(
-    log,
-    sdkClientFactory(params) as SplitIO.IClient,
-    key
-  );
-
-  const parsedDefaultKey = keyParser(key);
-  const defaultInstanceId = buildInstanceId(parsedDefaultKey);
-
-  // Cache instances created per factory.
-  clients[defaultInstanceId] = mainClientInstance;
-
-  return function client(key?: SplitIO.SplitKey) {
-    if (key === undefined) {
-      log.debug(RETRIEVE_CLIENT_DEFAULT);
-      return mainClientInstance;
-    }
-
-    // Validate the key value
-    const validKey = validateKey(log, key, LOG_PREFIX_CLIENT_INSTANTIATION);
-    if (validKey === false) {
-      throw new Error('Shared Client needs a valid key.');
-    }
-
-    const instanceId = buildInstanceId(validKey);
-
-    if (!clients[instanceId]) {
-      const matchingKey = getMatching(validKey);
-
-      const sharedSdkReadiness = sdkReadinessManager.shared();
-      const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
-        if (err) {
-          sharedSdkReadiness.readinessManager.timeout();
-          return;
-        }
-        // Emit SDK_READY in consumer mode for shared clients
-        sharedSdkReadiness.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
-      });
-
-      // 3 possibilities:
-      // - Standalone mode: both syncManager and sharedSyncManager are defined
-      // - Consumer mode: both syncManager and sharedSyncManager are undefined
-      // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
-      // @ts-ignore
-      const sharedSyncManager = syncManager && sharedStorage && (syncManager as ISyncManagerCS).shared(matchingKey, sharedSdkReadiness.readinessManager, sharedStorage);
-
-      // As shared clients reuse all the storage information, we don't need to check here if we
-      // will use offline or online mode. We should stick with the original decision.
-      clients[instanceId] = clientCSDecorator(
-        log,
-        sdkClientFactory(objectAssign({}, params, {
-          sdkReadinessManager: sharedSdkReadiness,
-          storage: sharedStorage || storage,
-          syncManager: sharedSyncManager,
-        }), true) as SplitIO.IClient,
-        validKey
-      );
-
-      log.info(NEW_SHARED_CLIENT);
-    } else {
-      log.debug(RETRIEVE_CLIENT_EXISTING);
-    }
-
-    return clients[instanceId] as SplitIO.IBrowserClient;
-  };
-}

package/src/sdkFactory/index.ts

@@ -1,131 +0,0 @@
-import { ISdkFactoryContext, ISdkFactoryContextSync, ISdkFactoryParams } from './types';
-import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
-import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
-import { eventTrackerFactory } from '../trackers/eventTracker';
-import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import SplitIO from '../../types/splitio';
-import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
-import { createLoggerAPI } from '../logger/sdkLogger';
-import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } 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 { DEBUG, OPTIMIZED } from '../utils/constants';
-
-/**
- * Modular SDK factory
- */
-export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IAsyncSDK | SplitIO.IBrowserSDK | SplitIO.IBrowserAsyncSDK {
-
-  const { settings, platform, storageFactory, splitApiFactory, extraProps,
-    syncManagerFactory, SignalListener, impressionsObserverFactory,
-    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory, lazyInit } = params;
-  const { log, sync: { impressionsMode } } = settings;
-
-  // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
-  // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-
-  // initialization
-  let hasInit = false;
-  const initCallbacks: (() => void)[] = [];
-
-  function whenInit(cb: () => void) {
-    if (hasInit) cb();
-    else initCallbacks.push(cb);
-  }
-
-  const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
-  const readiness = sdkReadinessManager.readinessManager;
-
-  const storage = storageFactory({
-    settings,
-    onReadyCb: (error) => {
-      if (error) {
-        // If storage fails to connect, SDK_READY_TIMED_OUT event is emitted immediately. Review when timeout and non-recoverable errors are reworked
-        readiness.timeout();
-        return;
-      }
-      readiness.splits.emit(SDK_SPLITS_ARRIVED);
-      readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-    },
-    onReadyFromCacheCb: () => {
-      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-    }
-  });
-  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
-  const clients: Record<string, SplitIO.IBasicClient> = {};
-  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
-  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
-
-  const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
-
-  const noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
-  const strategy = impressionsMode === OPTIMIZED ?
-    strategyOptimizedFactory(observer, storage.impressionCounts) :
-    impressionsMode === DEBUG ?
-      strategyDebugFactory(observer) :
-      noneStrategy;
-
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
-
-  // splitApi is used by SyncManager and Browser signal listener
-  const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
-
-  const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
-  ctx.syncManager = syncManager;
-
-  const signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
-  ctx.signalListener = signalListener;
-
-  // SDK client and manager
-  const clientMethod = sdkClientMethodFactory(ctx);
-  const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-
-
-  function init() {
-    if (hasInit) return;
-    hasInit = true;
-
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    validateAndTrackApiKey(log, settings.core.authorizationKey);
-    readiness.init();
-    uniqueKeysTracker.start();
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
-
-    initCallbacks.forEach((cb) => cb());
-    initCallbacks.length = 0;
-  }
-
-  log.info(NEW_FACTORY);
-
-  // @ts-ignore
-  return objectAssign({
-    // Split evaluation and event tracking engine
-    client: clientMethod,
-
-    // Manager API to explore available information
-    manager() {
-      log.debug(RETRIEVE_MANAGER);
-      return managerInstance;
-    },
-
-    // Logger wrapper API
-    Logger: createLoggerAPI(log),
-
-    settings,
-
-    destroy() {
-      hasInit = false;
-      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
-    }
-  }, extraProps && extraProps(ctx), lazyInit ? { init } : init());
-}