@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/esm/platform/getEventSource/eventsource.js

@@ -0,0 +1,480 @@
+"use strict";
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable no-restricted-syntax */
+/*
+Modified version of "eventsource" v1.1.2 package (https://www.npmjs.com/package/eventsource/v/1.1.2)
+that accepts a custom agent.
+
+The MIT License
+
+Copyright (c) EventSource GitHub organisation
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+var parse = require('url').parse;
+var events = require('events');
+var https = require('https');
+var http = require('http');
+var util = require('util');
+var httpsOptions = [
+    'pfx', 'key', 'passphrase', 'cert', 'ca', 'ciphers',
+    'rejectUnauthorized', 'secureProtocol', 'servername', 'checkServerIdentity'
+];
+var bom = [239, 187, 191];
+var colon = 58;
+var space = 32;
+var lineFeed = 10;
+var carriageReturn = 13;
+function hasBom(buf) {
+    return bom.every(function (charCode, index) {
+        return buf[index] === charCode;
+    });
+}
+/**
+ * Creates a new EventSource object
+ *
+ * @param {String} url the URL to which to connect
+ * @param {Object} [eventSourceInitDict] extra init params. See README for details.
+ * @api public
+ **/
+function EventSource(url, eventSourceInitDict) {
+    var readyState = EventSource.CONNECTING;
+    var headers = eventSourceInitDict && eventSourceInitDict.headers;
+    var hasNewOrigin = false;
+    Object.defineProperty(this, 'readyState', {
+        get: function () {
+            return readyState;
+        }
+    });
+    Object.defineProperty(this, 'url', {
+        get: function () {
+            return url;
+        }
+    });
+    var self = this;
+    self.reconnectInterval = 1000;
+    self.connectionInProgress = false;
+    var reconnectUrl = null;
+    function onConnectionClosed(message) {
+        if (readyState === EventSource.CLOSED)
+            return;
+        readyState = EventSource.CONNECTING;
+        _emit('error', new Event('error', { message: message }));
+        // The url may have been changed by a temporary redirect. If that's the case,
+        // revert it now, and flag that we are no longer pointing to a new origin
+        if (reconnectUrl) {
+            url = reconnectUrl;
+            reconnectUrl = null;
+            hasNewOrigin = false;
+        }
+        setTimeout(function () {
+            if (readyState !== EventSource.CONNECTING || self.connectionInProgress) {
+                return;
+            }
+            self.connectionInProgress = true;
+            connect();
+        }, self.reconnectInterval);
+    }
+    var req;
+    var lastEventId = '';
+    if (headers && headers['Last-Event-ID']) {
+        lastEventId = headers['Last-Event-ID'];
+        delete headers['Last-Event-ID'];
+    }
+    var discardTrailingNewline = false;
+    var data = '';
+    var eventName = '';
+    function connect() {
+        var options = parse(url);
+        var isSecure = options.protocol === 'https:';
+        options.headers = { 'Cache-Control': 'no-cache', 'Accept': 'text/event-stream' };
+        if (lastEventId)
+            options.headers['Last-Event-ID'] = lastEventId;
+        if (headers) {
+            var reqHeaders = hasNewOrigin ? removeUnsafeHeaders(headers) : headers;
+            for (var i in reqHeaders) {
+                var header = reqHeaders[i];
+                if (header) {
+                    options.headers[i] = header;
+                }
+            }
+        }
+        // Legacy: this should be specified as `eventSourceInitDict.https.rejectUnauthorized`,
+        // but for now exists as a backwards-compatibility layer
+        options.rejectUnauthorized = !(eventSourceInitDict && !eventSourceInitDict.rejectUnauthorized);
+        if (eventSourceInitDict && eventSourceInitDict.createConnection !== undefined) {
+            options.createConnection = eventSourceInitDict.createConnection;
+        }
+        // If specify agent, use it.
+        if (eventSourceInitDict && eventSourceInitDict.agent !== undefined) {
+            options.agent = eventSourceInitDict.agent;
+        }
+        // If specify http proxy, make the request to sent to the proxy server,
+        // and include the original url in path and Host headers
+        var useProxy = eventSourceInitDict && eventSourceInitDict.proxy;
+        if (useProxy) {
+            var proxy = parse(eventSourceInitDict.proxy);
+            isSecure = proxy.protocol === 'https:';
+            options.protocol = isSecure ? 'https:' : 'http:';
+            options.path = url;
+            options.headers.Host = options.host;
+            options.hostname = proxy.hostname;
+            options.host = proxy.host;
+            options.port = proxy.port;
+        }
+        // If https options are specified, merge them into the request options
+        if (eventSourceInitDict && eventSourceInitDict.https) {
+            for (var optName in eventSourceInitDict.https) {
+                if (httpsOptions.indexOf(optName) === -1) {
+                    continue;
+                }
+                var option = eventSourceInitDict.https[optName];
+                if (option !== undefined) {
+                    options[optName] = option;
+                }
+            }
+        }
+        // Pass this on to the XHR
+        if (eventSourceInitDict && eventSourceInitDict.withCredentials !== undefined) {
+            options.withCredentials = eventSourceInitDict.withCredentials;
+        }
+        req = (isSecure ? https : http).request(options, function (res) {
+            self.connectionInProgress = false;
+            // Handle HTTP errors
+            if (res.statusCode === 500 || res.statusCode === 502 || res.statusCode === 503 || res.statusCode === 504) {
+                _emit('error', new Event('error', { status: res.statusCode, message: res.statusMessage }));
+                onConnectionClosed();
+                return;
+            }
+            // Handle HTTP redirects
+            if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307) {
+                var location = res.headers.location;
+                if (!location) {
+                    // Server sent redirect response without Location header.
+                    _emit('error', new Event('error', { status: res.statusCode, message: res.statusMessage }));
+                    return;
+                }
+                var prevOrigin = getOrigin(url);
+                var nextOrigin = getOrigin(location);
+                hasNewOrigin = prevOrigin !== nextOrigin;
+                if (res.statusCode === 307)
+                    reconnectUrl = url;
+                url = location;
+                process.nextTick(connect);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                _emit('error', new Event('error', { status: res.statusCode, message: res.statusMessage }));
+                return self.close();
+            }
+            readyState = EventSource.OPEN;
+            res.on('close', function () {
+                res.removeAllListeners('close');
+                res.removeAllListeners('end');
+                onConnectionClosed();
+            });
+            res.on('end', function () {
+                res.removeAllListeners('close');
+                res.removeAllListeners('end');
+                onConnectionClosed();
+            });
+            _emit('open', new Event('open'));
+            // text/event-stream parser adapted from webkit's
+            // Source/WebCore/page/EventSource.cpp
+            var isFirst = true;
+            var buf;
+            var startingPos = 0;
+            var startingFieldLength = -1;
+            res.on('data', function (chunk) {
+                buf = buf ? Buffer.concat([buf, chunk]) : chunk;
+                if (isFirst && hasBom(buf)) {
+                    buf = buf.slice(bom.length);
+                }
+                isFirst = false;
+                var pos = 0;
+                var length = buf.length;
+                while (pos < length) {
+                    if (discardTrailingNewline) {
+                        if (buf[pos] === lineFeed) {
+                            ++pos;
+                        }
+                        discardTrailingNewline = false;
+                    }
+                    var lineLength = -1;
+                    var fieldLength = startingFieldLength;
+                    var c;
+                    for (var i = startingPos; lineLength < 0 && i < length; ++i) {
+                        c = buf[i];
+                        if (c === colon) {
+                            if (fieldLength < 0) {
+                                fieldLength = i - pos;
+                            }
+                        }
+                        else if (c === carriageReturn) {
+                            discardTrailingNewline = true;
+                            lineLength = i - pos;
+                        }
+                        else if (c === lineFeed) {
+                            lineLength = i - pos;
+                        }
+                    }
+                    if (lineLength < 0) {
+                        startingPos = length - pos;
+                        startingFieldLength = fieldLength;
+                        break;
+                    }
+                    else {
+                        startingPos = 0;
+                        startingFieldLength = -1;
+                    }
+                    parseEventStreamLine(buf, pos, fieldLength, lineLength);
+                    pos += lineLength + 1;
+                }
+                if (pos === length) {
+                    buf = void 0;
+                }
+                else if (pos > 0) {
+                    buf = buf.slice(pos);
+                }
+            });
+        });
+        req.on('error', function (err) {
+            self.connectionInProgress = false;
+            onConnectionClosed(err.message);
+        });
+        if (req.setNoDelay)
+            req.setNoDelay(true);
+        req.end();
+    }
+    connect();
+    function _emit() {
+        if (self.listeners(arguments[0]).length > 0) {
+            self.emit.apply(self, arguments);
+        }
+    }
+    this._close = function () {
+        if (readyState === EventSource.CLOSED)
+            return;
+        readyState = EventSource.CLOSED;
+        if (req.abort)
+            req.abort();
+        if (req.xhr && req.xhr.abort)
+            req.xhr.abort();
+    };
+    function parseEventStreamLine(buf, pos, fieldLength, lineLength) {
+        if (lineLength === 0) {
+            if (data.length > 0) {
+                var type = eventName || 'message';
+                _emit(type, new MessageEvent(type, {
+                    data: data.slice(0, -1),
+                    lastEventId: lastEventId,
+                    origin: getOrigin(url)
+                }));
+                data = '';
+            }
+            eventName = void 0;
+        }
+        else if (fieldLength > 0) {
+            var noValue = fieldLength < 0;
+            var step = 0;
+            var field = buf.slice(pos, pos + (noValue ? lineLength : fieldLength)).toString();
+            if (noValue) {
+                step = lineLength;
+            }
+            else if (buf[pos + fieldLength + 1] !== space) {
+                step = fieldLength + 1;
+            }
+            else {
+                step = fieldLength + 2;
+            }
+            pos += step;
+            var valueLength = lineLength - step;
+            var value = buf.slice(pos, pos + valueLength).toString();
+            if (field === 'data') {
+                data += value + '\n';
+            }
+            else if (field === 'event') {
+                eventName = value;
+            }
+            else if (field === 'id') {
+                lastEventId = value;
+            }
+            else if (field === 'retry') {
+                var retry = parseInt(value, 10);
+                if (!Number.isNaN(retry)) {
+                    self.reconnectInterval = retry;
+                }
+            }
+        }
+    }
+}
+module.exports = EventSource;
+util.inherits(EventSource, events.EventEmitter);
+EventSource.prototype.constructor = EventSource; // make stacktraces readable
+['open', 'error', 'message'].forEach(function (method) {
+    Object.defineProperty(EventSource.prototype, 'on' + method, {
+        /**
+         * Returns the current listener
+         *
+         * @return {Mixed} the set function or undefined
+         * @api private
+         */
+        get: function get() {
+            var listener = this.listeners(method)[0];
+            return listener ? (listener._listener ? listener._listener : listener) : undefined;
+        },
+        /**
+         * Start listening for events
+         *
+         * @param {Function} listener the listener
+         * @return {Mixed} the set function or undefined
+         * @api private
+         */
+        set: function set(listener) {
+            this.removeAllListeners(method);
+            this.addEventListener(method, listener);
+        }
+    });
+});
+/**
+ * Ready states
+ */
+Object.defineProperty(EventSource, 'CONNECTING', { enumerable: true, value: 0 });
+Object.defineProperty(EventSource, 'OPEN', { enumerable: true, value: 1 });
+Object.defineProperty(EventSource, 'CLOSED', { enumerable: true, value: 2 });
+EventSource.prototype.CONNECTING = 0;
+EventSource.prototype.OPEN = 1;
+EventSource.prototype.CLOSED = 2;
+/**
+ * Closes the connection, if one is made, and sets the readyState attribute to 2 (closed)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/EventSource/close
+ * @api public
+ */
+EventSource.prototype.close = function () {
+    this._close();
+};
+/**
+ * Emulates the W3C Browser based WebSocket interface using addEventListener.
+ *
+ * @param {String} type A string representing the event type to listen out for
+ * @param {Function} listener callback
+ * @see https://developer.mozilla.org/en/DOM/element.addEventListener
+ * @see http://dev.w3.org/html5/websockets/#the-websocket-interface
+ * @api public
+ */
+EventSource.prototype.addEventListener = function addEventListener(type, listener) {
+    if (typeof listener === 'function') {
+        // store a reference so we can return the original function again
+        listener._listener = listener;
+        this.on(type, listener);
+    }
+};
+/**
+ * Emulates the W3C Browser based WebSocket interface using dispatchEvent.
+ *
+ * @param {Event} event An event to be dispatched
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent
+ * @api public
+ */
+EventSource.prototype.dispatchEvent = function dispatchEvent(event) {
+    if (!event.type) {
+        throw new Error('UNSPECIFIED_EVENT_TYPE_ERR');
+    }
+    // if event is instance of an CustomEvent (or has 'details' property),
+    // send the detail object as the payload for the event
+    this.emit(event.type, event.detail);
+};
+/**
+ * Emulates the W3C Browser based WebSocket interface using removeEventListener.
+ *
+ * @param {String} type A string representing the event type to remove
+ * @param {Function} listener callback
+ * @see https://developer.mozilla.org/en/DOM/element.removeEventListener
+ * @see http://dev.w3.org/html5/websockets/#the-websocket-interface
+ * @api public
+ */
+EventSource.prototype.removeEventListener = function removeEventListener(type, listener) {
+    if (typeof listener === 'function') {
+        listener._listener = undefined;
+        this.removeListener(type, listener);
+    }
+};
+/**
+ * W3C Event
+ *
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#interface-Event
+ * @api private
+ */
+function Event(type, optionalProperties) {
+    Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true });
+    if (optionalProperties) {
+        for (var f in optionalProperties) {
+            if (optionalProperties.hasOwnProperty(f)) {
+                Object.defineProperty(this, f, { writable: false, value: optionalProperties[f], enumerable: true });
+            }
+        }
+    }
+}
+/**
+ * W3C MessageEvent
+ *
+ * @see http://www.w3.org/TR/webmessaging/#event-definitions
+ * @api private
+ */
+function MessageEvent(type, eventInitDict) {
+    Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true });
+    for (var f in eventInitDict) {
+        if (eventInitDict.hasOwnProperty(f)) {
+            Object.defineProperty(this, f, { writable: false, value: eventInitDict[f], enumerable: true });
+        }
+    }
+}
+/**
+ * Returns a new object of headers that does not include any authorization and cookie headers
+ *
+ * @param {Object} headers An object of headers ({[headerName]: headerValue})
+ * @return {Object} a new object of headers
+ * @api private
+ */
+function removeUnsafeHeaders(headers) {
+    var safe = {};
+    for (var key in headers) {
+        if (/^(cookie|authorization)$/i.test(key)) {
+            continue;
+        }
+        safe[key] = headers[key];
+    }
+    return safe;
+}
+/**
+ * Transform an URL to a valid origin value.
+ *
+ * @param {String|Object} url URL to transform to it's origin.
+ * @returns {String} The origin.
+ * @api private
+ */
+function getOrigin(url) {
+    if (typeof url === 'string')
+        url = parse(url);
+    if (!url.protocol || !url.hostname)
+        return 'null';
+    return (url.protocol + '//' + url.host).toLowerCase();
+}

package/esm/platform/getEventSource/node.js

@@ -0,0 +1,19 @@
+var __isCustom = false;
+var __eventSource = undefined;
+// This function is only exposed for testing purposes.
+export function __setEventSource(eventSource) {
+    __eventSource = eventSource;
+    __isCustom = true;
+}
+export function __restore() {
+    __isCustom = false;
+}
+export function getEventSource() {
+    // returns EventSource at `eventsource` package. If not available, return global EventSource or undefined
+    try {
+        return __isCustom ? __eventSource : require('./eventsource');
+    }
+    catch (error) {
+        return typeof EventSource === 'function' ? EventSource : undefined;
+    }
+}

package/esm/platform/getEventSource/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/esm/platform/getFetch/browser.js

@@ -0,0 +1,4 @@
+import unfetch from 'unfetch';
+export function getFetch() {
+    return typeof fetch === 'function' ? fetch : unfetch;
+}

package/esm/platform/getFetch/node.js

@@ -0,0 +1,21 @@
+var nodeFetch;
+try {
+    nodeFetch = require('node-fetch');
+    // Handle node-fetch issue https://github.com/node-fetch/node-fetch/issues/1037
+    if (typeof nodeFetch !== 'function')
+        nodeFetch = nodeFetch.default;
+}
+catch (error) {
+    // Try to access global fetch if `node-fetch` package couldn't be imported (e.g., not in a Node environment)
+    nodeFetch = typeof fetch === 'function' ? fetch : undefined;
+}
+// This function is only exposed for testing purposes.
+export function __setFetch(fetch) {
+    nodeFetch = fetch;
+}
+/**
+ * Retrieves 'node-fetch', a Fetch API polyfill for Node.js, with fallback to global 'fetch' if available.
+ */
+export function getFetch() {
+    return nodeFetch;
+}

package/esm/platform/getFetch/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/esm/platform/getOptions/node.js

@@ -0,0 +1,20 @@
+// @TODO
+// 1- handle multiple protocols automatically
+// 2- destroy it once the sdk is destroyed
+import https from 'https';
+import { find } from '@splitsoftware/splitio-commons/esm/utils/lang';
+var agent = new https.Agent({
+    keepAlive: true,
+    keepAliveMsecs: 1500
+});
+export function getOptions(settings) {
+    // User provided options take precedence
+    if (settings.sync.requestOptions)
+        return settings.sync.requestOptions;
+    // If some URL is not HTTPS, we don't use the agent, to let the SDK connect to HTTP endpoints
+    if (find(settings.urls, function (url) { return !url.startsWith('https:'); }))
+        return;
+    return {
+        agent: agent
+    };
+}

package/esm/platform/node.js

@@ -0,0 +1,14 @@
+import EventEmitter from 'events';
+import { getFetch } from '../platform/getFetch/node';
+import { getEventSource } from '../platform/getEventSource/node';
+import { getOptions } from '../platform/getOptions/node';
+import { NodeSignalListener } from '@splitsoftware/splitio-commons/esm/listeners/node';
+import { now } from '@splitsoftware/splitio-commons/esm/utils/timeTracker/now/node';
+export var platform = {
+    getFetch: getFetch,
+    getEventSource: getEventSource,
+    getOptions: getOptions,
+    EventEmitter: EventEmitter,
+    now: now
+};
+export var SignalListener = NodeSignalListener;

package/esm/platform/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/esm/settings/browser.js

@@ -0,0 +1,17 @@
+import { settingsValidation } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation';
+import { validateRuntime } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/runtime';
+import { validateLogger } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/logger/builtinLogger';
+import { validateConsent } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/consent';
+import { defaults } from './defaults/browser';
+import { validateStorage } from './storage/browser';
+var params = {
+    defaults: defaults,
+    acceptKey: true,
+    runtime: validateRuntime,
+    storage: validateStorage,
+    logger: validateLogger,
+    consent: validateConsent,
+};
+export function settingsFactory(config) {
+    return settingsValidation(config, params);
+}

package/esm/settings/defaults/browser.js

@@ -0,0 +1,18 @@
+import { packageVersion } from './version';
+import { CONSENT_GRANTED } from '@splitsoftware/splitio-commons/esm/utils/constants';
+export var defaults = {
+    startup: {
+        // Stress the request time used while starting up the SDK.
+        requestTimeoutBeforeReady: 5,
+        // How many quick retries we will do while starting up the SDK.
+        retriesOnFailureBeforeReady: 1,
+        // Maximum amount of time used before notifies me a timeout.
+        readyTimeout: 10,
+        // Amount of time we will wait before the first push of events.
+        eventsFirstPushWindow: 10
+    },
+    // Consent is considered granted by default
+    userConsent: CONSENT_GRANTED,
+    // Instance version.
+    version: "javascript-" + packageVersion,
+};

package/esm/settings/defaults/node.js

@@ -0,0 +1,20 @@
+import { packageVersion } from './version';
+export var defaults = {
+    core: {
+        // Default is true.
+        IPAddressesEnabled: true
+    },
+    startup: {
+        // Stress the request time used while starting up the SDK.
+        requestTimeoutBeforeReady: 15,
+        // How many quick retries we will do while starting up the SDK.
+        retriesOnFailureBeforeReady: 1,
+        // Maximum amount of time used before notifies me a timeout.
+        readyTimeout: 15,
+        // Don't wait a specific time for first flush on Node, no page load here.
+        eventsFirstPushWindow: 0
+    },
+    features: '.split',
+    // Instance version.
+    version: "nodejs-" + packageVersion,
+};

package/esm/settings/defaults/version.js

@@ -0,0 +1 @@
+export var packageVersion = '11.5.0-rc.0';

package/esm/settings/integrations/browser.js

@@ -0,0 +1,5 @@
+import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS } from '@splitsoftware/splitio-commons/esm/utils/constants/browser';
+import { validateConfigurableIntegrations } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/integrations/configurable';
+export function validateIntegrations(settings) {
+    return validateConfigurableIntegrations(settings, [GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS]);
+}

package/esm/settings/node.js

@@ -0,0 +1,18 @@
+import { settingsValidation } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation';
+import { validateLogger } from '@splitsoftware/splitio-commons/esm/utils/settingsValidation/logger/builtinLogger';
+import { defaults } from './defaults/node';
+import { validateStorage } from './storage/node';
+import { validateRuntime } from './runtime/node';
+var params = {
+    defaults: defaults,
+    runtime: validateRuntime,
+    storage: validateStorage,
+    logger: validateLogger,
+};
+export function settingsFactory(config) {
+    var settings = settingsValidation(config, params);
+    // if provided, keeps reference to the `requestOptions` object
+    if (settings.sync.requestOptions)
+        settings.sync.requestOptions = config.sync.requestOptions;
+    return settings;
+}

package/esm/settings/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}