@splitsoftware/splitio-commons/esm/sdkFactory/index.js

Split JavaScript SDK common components

import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
import { eventTrackerFactory } from '../trackers/eventTracker';
import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
import { createLoggerAPI } from '../logger/sdkLogger';
import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
import { objectAssign } from '../utils/lang/objectAssign';
import { setRolloutPlan } from '../storages/setRolloutPlan';
import { getMatching } from '../utils/key';
import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
/**
 * Modular SDK factory
 */
export function sdkFactory(params) {
    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, serviceApiFactory = params.serviceApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, lazyInit = params.lazyInit;
    var log = settings.log, initialRolloutPlan = settings.initialRolloutPlan, key = settings.core.key;
    // @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.
    var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
    var readiness = sdkReadinessManager.readinessManager;
    var storage = storageFactory({
        settings: settings,
        onReadyCb: function (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.definitions.emit(SDK_DEFINITIONS_ARRIVED);
            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
        },
        onReadyFromCacheCb: function () {
            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED);
        }
    });
    var fallbackCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
    if (initialRolloutPlan) {
        setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
        if (storage.definitions.getChangeNumber() > -1)
            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
    }
    var clients = {};
    var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
    var impressionsTracker = impressionsTrackerFactory(params, storage, integrationsManager);
    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
    // serviceApi is used by SyncManager and Browser signal listener
    var serviceApi = serviceApiFactory && serviceApiFactory(settings, platform, telemetryTracker);
    var ctx = { clients: clients, serviceApi: serviceApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackCalculator: fallbackCalculator };
    ctx.syncManager = syncManagerFactory && syncManagerFactory(ctx);
    // SDK client and manager
    var clientMethod = sdkClientMethodFactory(ctx);
    var managerInstance = sdkManagerFactory(settings, storage.definitions, sdkReadinessManager);
    function init() {
        Object.keys(clients).map(function (key) { return clients[key].init(); });
    }
    log.info(NEW_FACTORY, [settings.version]);
    // @ts-ignore
    return objectAssign({
        // Split evaluation and event tracking engine
        client: clientMethod,
        // Manager API to explore available information
        manager: function () {
            log.debug(RETRIEVE_MANAGER);
            return managerInstance;
        },
        // Logger wrapper API
        Logger: createLoggerAPI(log),
        settings: settings,
        destroy: function () {
            return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
        }
    }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());
}