@splitsoftware/splitio 10.26.1-rc.1 → 10.26.1-rc.2

package/CHANGES.txt

@@ -1,3 +1,6 @@
+10.27.0
+ - it must return an object that adheres to the NodeJS http/s request options object (https://nodejs.org/api/https.html#httpsrequesturl-options-callback)
+
 10.26.1 (June XX, 2024)
  - Updated the internal imports of 'os' and 'ioredis' modules for NodeJS to use EcmaScript 'import' rather than CommonJS 'require' for the ES modules build, avoiding runtime errors when bundling or importing the SDK in a .mjs file.
  - Updated @splitsoftware/splitio-commons package to version 1.15.1 that includes updates on input validation logs.

package/es/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/es/platform/getEventSource/node.js

@@ -11,7 +11,7 @@ export function __restore() {
 export function getEventSource() {
     // returns EventSource at `eventsource` package. If not available, return global EventSource or undefined
     try {
-        return __isCustom ? __eventSource : require('eventsource');
+        return __isCustom ? __eventSource : require('./eventsource');
     }
     catch (error) {
         return typeof EventSource === 'function' ? EventSource : undefined;

package/es/platform/getFetch/node.js

@@ -1,12 +1,3 @@
-/* eslint-disable compat/compat */
-import https from 'https';
-// @TODO
-// 1- handle multiple protocols automatically
-// 2- destroy it once the sdk is destroyed
-var agent = new https.Agent({
-    keepAlive: true,
-    keepAliveMsecs: 1500
-});
 var nodeFetch;
 try {
     nodeFetch = require('node-fetch');
@@ -24,12 +15,7 @@ export function __setFetch(fetch) {
 }
 /**
  * Retrieves 'node-fetch', a Fetch API polyfill for NodeJS, with fallback to global 'fetch' if available.
- * It passes an https agent with keepAlive enabled if URL is https.
  */
 export function getFetch() {
-    if (nodeFetch) {
-        return function (url, options) {
-            return nodeFetch(url, Object.assign({ agent: url.startsWith('https:') ? agent : undefined }, options));
-        };
-    }
+    return nodeFetch;
 }

package/es/platform/getOptions/node.js

@@ -0,0 +1,17 @@
+// @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) {
+    // 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/es/platform/node.js

@@ -1,11 +1,13 @@
 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
 };

package/es/settings/defaults/version.js

@@ -1 +1 @@
-export var packageVersion = '10.26.1-rc.1';
+export var packageVersion = '10.26.1-rc.2';