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

Split JavaScript SDK common components

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.sdkFactory = void 0;
var sdkReadinessManager_1 = require("../readiness/sdkReadinessManager");
var impressionsTracker_1 = require("../trackers/impressionsTracker");
var eventTracker_1 = require("../trackers/eventTracker");
var telemetryTracker_1 = require("../trackers/telemetryTracker");
var sdkLogger_1 = require("../logger/sdkLogger");
var constants_1 = require("../logger/constants");
var constants_2 = require("../readiness/constants");
var objectAssign_1 = require("../utils/lang/objectAssign");
var setRolloutPlan_1 = require("../storages/setRolloutPlan");
var key_1 = require("../utils/key");
var fallbackTreatmentsCalculator_1 = require("../evaluator/fallbackTreatmentsCalculator");
/**
 * Modular SDK factory
 */
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 = (0, sdkReadinessManager_1.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(constants_2.SDK_DEFINITIONS_ARRIVED);
            readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
        },
        onReadyFromCacheCb: function () {
            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_CACHE_LOADED);
        }
    });
    var fallbackCalculator = (0, fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator)(settings.fallbackTreatments);
    if (initialRolloutPlan) {
        (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, storage, key && (0, key_1.getMatching)(key));
        if (storage.definitions.getChangeNumber() > -1)
            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
    }
    var clients = {};
    var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
    var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(params, storage, integrationsManager);
    var eventTracker = (0, eventTracker_1.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(constants_1.NEW_FACTORY, [settings.version]);
    // @ts-ignore
    return (0, objectAssign_1.objectAssign)({
        // Split evaluation and event tracking engine
        client: clientMethod,
        // Manager API to explore available information
        manager: function () {
            log.debug(constants_1.RETRIEVE_MANAGER);
            return managerInstance;
        },
        // Logger wrapper API
        Logger: (0, sdkLogger_1.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());
}
exports.sdkFactory = sdkFactory;