@splitsoftware/splitio-commons/cjs/readiness/sdkReadinessManager.js

Split JavaScript SDK common components

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.sdkReadinessManagerFactory = void 0;
var objectAssign_1 = require("../utils/lang/objectAssign");
var wrapper_1 = require("../utils/promise/wrapper");
var readinessManager_1 = require("./readinessManager");
var constants_1 = require("./constants");
var constants_2 = require("../logger/constants");
var NEW_LISTENER_EVENT = 'newListener';
var TIMEOUT_ERROR = new Error(constants_1.SDK_READY_TIMED_OUT);
/**
 * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
 * It also updates logs related warnings and errors.
 *
 * @param readyTimeout - time in millis to emit SDK_READY_TIME_OUT event
 * @param readinessManager - optional readinessManager to use. only used internally for `shared` method
 */
function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
    if (readinessManager === void 0) { readinessManager = (0, readinessManager_1.readinessManagerFactory)(EventEmitter, settings); }
    var log = settings.log;
    readinessManager.gate.on(NEW_LISTENER_EVENT, function (event) {
        if (event === constants_1.SDK_READY || event === constants_1.SDK_READY_TIMED_OUT) {
            if (readinessManager.isReady()) {
                log.error(constants_2.ERROR_CLIENT_LISTENER, [event === constants_1.SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);
            }
        }
        else if (event === constants_1.SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
            log.error(constants_2.ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
        }
    });
    /** Ready promise */
    var readyPromise = generateReadyPromise();
    readinessManager.gate.once(constants_1.SDK_READY_FROM_CACHE, function () {
        log.info(constants_2.CLIENT_READY_FROM_CACHE);
    });
    // default onRejected handler, that just logs the error, if ready promise doesn't have one.
    function defaultOnRejected(err) {
        log.error(err && err.message);
    }
    function generateReadyPromise() {
        var promise = (0, wrapper_1.promiseWrapper)(new Promise(function (resolve, reject) {
            readinessManager.gate.once(constants_1.SDK_READY, function () {
                log.info(constants_2.CLIENT_READY);
                resolve();
            });
            readinessManager.gate.once(constants_1.SDK_READY_TIMED_OUT, function (message) {
                reject(new Error(message));
            });
        }), defaultOnRejected);
        return promise;
    }
    function getStatus() {
        return {
            isReady: readinessManager.isReady(),
            isReadyFromCache: readinessManager.isReadyFromCache(),
            isTimedout: readinessManager.isTimedout(),
            hasTimedout: readinessManager.hasTimedout(),
            isDestroyed: readinessManager.isDestroyed(),
            isOperational: readinessManager.isOperational(),
            lastUpdate: readinessManager.lastUpdate(),
        };
    }
    return {
        readinessManager: readinessManager,
        shared: function () {
            return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
        },
        sdkStatus: (0, objectAssign_1.objectAssign)(
        // Expose Event Emitter functionality
        Object.create(readinessManager.gate), {
            // Expose the event constants without changing the interface
            Event: {
                SDK_READY: constants_1.SDK_READY,
                SDK_READY_FROM_CACHE: constants_1.SDK_READY_FROM_CACHE,
                SDK_UPDATE: constants_1.SDK_UPDATE,
                SDK_READY_TIMED_OUT: constants_1.SDK_READY_TIMED_OUT,
            },
            // @TODO: remove in next major
            ready: function () {
                if (readinessManager.hasTimedout()) {
                    if (!readinessManager.isReady()) {
                        return (0, wrapper_1.promiseWrapper)(Promise.reject(new Error('SDK client has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
                    }
                    else {
                        return Promise.resolve();
                    }
                }
                return readyPromise;
            },
            whenReady: function () {
                return new Promise(function (resolve, reject) {
                    if (readinessManager.isReady()) {
                        resolve(readinessManager.metadataReady());
                    }
                    else if (readinessManager.hasTimedout()) {
                        reject(TIMEOUT_ERROR);
                    }
                    else {
                        readinessManager.gate.once(constants_1.SDK_READY, resolve);
                        readinessManager.gate.once(constants_1.SDK_READY_TIMED_OUT, function () { return reject(TIMEOUT_ERROR); });
                    }
                });
            },
            whenReadyFromCache: function () {
                return new Promise(function (resolve, reject) {
                    if (readinessManager.isReadyFromCache()) {
                        resolve(readinessManager.metadataReady());
                    }
                    else if (readinessManager.hasTimedout()) {
                        reject(TIMEOUT_ERROR);
                    }
                    else {
                        readinessManager.gate.once(constants_1.SDK_READY_FROM_CACHE, resolve);
                        readinessManager.gate.once(constants_1.SDK_READY_TIMED_OUT, function () { return reject(TIMEOUT_ERROR); });
                    }
                });
            },
            getStatus: getStatus,
            // @TODO: remove in next major
            __getStatus: getStatus
        })
    };
}
exports.sdkReadinessManagerFactory = sdkReadinessManagerFactory;