@splitsoftware/splitio-commons
Version:
Split JavaScript SDK common components
111 lines (110 loc) • 6.5 kB
JavaScript
import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
import { eventTrackerFactory } from '../trackers/eventTracker';
import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
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';
import { setRolloutPlan } from '../storages/setRolloutPlan';
import { getMatching } from '../utils/key';
/**
* Modular SDK factory
*/
export function sdkFactory(params) {
var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
var log = settings.log, impressionsMode = settings.sync.impressionsMode, 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.
// initialization
var hasInit = false;
var initCallbacks = [];
function whenInit(cb) {
if (hasInit)
cb();
else
initCallbacks.push(cb);
}
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.splits.emit(SDK_SPLITS_ARRIVED);
readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
},
onReadyFromCacheCb: function () {
readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
}
});
if (initialRolloutPlan) {
setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
if (storage.splits.getChangeNumber() > -1)
readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
}
var clients = {};
var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
var observer = impressionsObserverFactory();
var uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
var noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
var strategy = impressionsMode === OPTIMIZED ?
strategyOptimizedFactory(observer, storage.impressionCounts) :
impressionsMode === DEBUG ?
strategyDebugFactory(observer) :
noneStrategy;
var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
var eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
// splitApi is used by SyncManager and Browser signal listener
var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
var syncManager = syncManagerFactory && syncManagerFactory(ctx);
ctx.syncManager = syncManager;
var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
ctx.signalListener = signalListener;
// SDK client and manager
var clientMethod = sdkClientMethodFactory(ctx);
var 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(function (cb) { return cb(); });
initCallbacks.length = 0;
}
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 () {
hasInit = false;
return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
}
}, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());
}