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

package/src/settings/integrations/browser.js

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

package/src/settings/node.js

@@ -0,0 +1,21 @@
+import { settingsValidation } from '@splitsoftware/splitio-commons/src/utils/settingsValidation';
+import { validateLogger } from '@splitsoftware/splitio-commons/src/utils/settingsValidation/logger/builtinLogger';
+
+import { defaults } from './defaults/node';
+import { validateStorage } from './storage/node';
+import { validateRuntime } from './runtime/node';
+
+const params = {
+  defaults,
+  runtime: validateRuntime,
+  storage: validateStorage,
+  logger: validateLogger,
+};
+
+export function settingsFactory(config) {
+  const 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/src/settings/package.json

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

package/src/settings/runtime/node.js

@@ -0,0 +1,21 @@
+import osFunction from 'os';
+import { address } from '../../utils/ip';
+
+import { UNKNOWN, NA, CONSUMER_MODE } from '@splitsoftware/splitio-commons/src/utils/constants';
+
+export function validateRuntime(settings) {
+  const isIPAddressesEnabled = settings.core.IPAddressesEnabled === true;
+  const isConsumerMode = settings.mode === CONSUMER_MODE;
+
+  // If the values are not available, default to false (for standalone) or "unknown" (for consumer mode, to be used on Redis keys)
+  let ip = address() || (isConsumerMode ? UNKNOWN : false);
+  let hostname = osFunction.hostname() || (isConsumerMode ? UNKNOWN : false);
+
+  if (!isIPAddressesEnabled) { // If IPAddresses setting is not enabled, set as false (for standalone) or "NA" (for consumer mode, to  be used on Redis keys)
+    ip = hostname = isConsumerMode ? NA : false;
+  }
+
+  return {
+    ip, hostname
+  };
+}

package/src/settings/storage/browser.js

@@ -0,0 +1,47 @@
+import { isLocalStorageAvailable } from '@splitsoftware/splitio-commons/src/utils/env/isLocalStorageAvailable';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '@splitsoftware/splitio-commons/src/utils/constants';
+
+const STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
+
+export function validateStorage(settings) {
+  let {
+    log,
+    mode,
+    storage: {
+      type,
+      options = {},
+      prefix,
+      expirationDays,
+      clearOnInit
+    } = { type: STORAGE_MEMORY },
+  } = settings;
+  let __originalType;
+
+  const fallbackToMemory = () => {
+    __originalType = type;
+    type = STORAGE_MEMORY;
+  };
+
+  // In localhost mode, fallback to Memory storage and track original type to emit SDK_READY_FROM_CACHE if corresponds.
+  // ATM, other mode settings (e.g., 'consumer') are ignored in client-side API, and so treated as standalone.
+  if (mode === LOCALHOST_MODE && type === STORAGE_LOCALSTORAGE) {
+    fallbackToMemory();
+  }
+
+  // If an invalid storage type is provided OR we want to use LOCALSTORAGE and
+  // it's not available, fallback into MEMORY
+  if (type !== STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE ||
+    type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {
+    fallbackToMemory();
+    log.error('Invalid or unavailable storage. Fallback into MEMORY storage');
+  }
+
+  return {
+    type,
+    options,
+    prefix,
+    expirationDays,
+    clearOnInit,
+    __originalType
+  };
+}

package/src/settings/storage/node.js

@@ -0,0 +1,84 @@
+import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS, CONSUMER_MODE, STANDALONE_MODE } from '@splitsoftware/splitio-commons/src/utils/constants';
+
+export function validateStorage(settings) {
+  const {
+    log,
+    mode,
+    storage: {
+      type,
+      options = {},
+      prefix
+    } = { type: STORAGE_MEMORY }
+  } = settings;
+
+  // We can have MEMORY, REDIS or an invalid storage type
+  switch (type) {
+    case STORAGE_REDIS: {
+      // If passing REDIS storage in localhost or standalone mode, we log an error and fallback to MEMORY storage
+      if (mode === STANDALONE_MODE || mode === LOCALHOST_MODE) {
+        log.error('The provided REDIS storage is invalid for this mode. It requires consumer mode. Fallback into default MEMORY storage.');
+        return {
+          type: STORAGE_MEMORY,
+          prefix
+        };
+      }
+      let {
+        host,
+        port,
+        db,
+        pass,
+        url,
+        tls,
+        connectionTimeout,
+        operationTimeout
+      } = options;
+
+      if (process.env.REDIS_HOST)
+        host = process.env.REDIS_HOST;
+      if (process.env.REDIS_PORT)
+        port = process.env.REDIS_PORT;
+      if (process.env.REDIS_DB)
+        db = process.env.REDIS_DB;
+      if (process.env.REDIS_PASS)
+        pass = process.env.REDIS_PASS;
+      if (process.env.REDIS_URL)
+        url = process.env.REDIS_URL;
+
+      const newOpts = {
+        connectionTimeout, operationTimeout
+      };
+
+      if (url) {
+        newOpts.url = url;
+      } else {
+        newOpts.host = host;
+        newOpts.port = port;
+        newOpts.db = db;
+        newOpts.pass = pass;
+      }
+
+      if (tls) {
+        newOpts.tls = tls;
+      }
+
+      return {
+        type,
+        prefix,
+        options: newOpts
+      };
+    }
+
+    // For now, we don't have modifiers or settings for MEMORY in Node.js
+    case STORAGE_MEMORY:
+    default: {
+      // If passing MEMORY storage in consumer mode, throw an error (no way to fallback to REDIS storage)
+      if (mode === CONSUMER_MODE) throw new Error('A REDIS storage is required on consumer mode');
+      // If passing an invalid storage type, log an error
+      if (type !== STORAGE_MEMORY) log.error(`The provided '${type}' storage type is invalid. Fallback into default MEMORY storage.`);
+      return {
+        type: STORAGE_MEMORY,
+        prefix
+      };
+    }
+  }
+}

package/src/sync/offline/LocalhostFromFile.js

@@ -0,0 +1,6 @@
+import { splitsParserFromFileFactory } from './splitsParserFromFile';
+import { syncManagerOfflineFactory } from '@splitsoftware/splitio-commons/src/sync/offline/syncManagerOffline';
+
+// Singleton instance of the factory function for offline SyncManager from YAML file
+// It uses Node.js APIs.
+export const localhostFromFileFactory = syncManagerOfflineFactory(splitsParserFromFileFactory);

package/src/sync/offline/splitsParserFromFile.js

@@ -0,0 +1,173 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { isString, endsWith, find, forOwn, uniq, } from '@splitsoftware/splitio-commons/src/utils/lang';
+import { parseCondition } from '@splitsoftware/splitio-commons/src/sync/offline/splitsParser/parseCondition';
+
+const logPrefix = 'sync:offline:fetcher: ';
+
+const DEFAULT_FILENAME = '.split';
+
+function configFilesPath(configFilePath) {
+  if (configFilePath === DEFAULT_FILENAME || !isString(configFilePath)) {
+    let root = process.env.HOME;
+
+    // @TODO env var not documented in help center
+    if (process.env.SPLIT_CONFIG_ROOT) root = process.env.SPLIT_CONFIG_ROOT;
+
+    if (!root) throw new Error('Missing root of the feature flags mock file.');
+
+    configFilePath = path.join(root, DEFAULT_FILENAME);
+  }
+
+  // Validate the extensions
+  if (!(endsWith(configFilePath, '.yaml', true) || endsWith(configFilePath, '.yml', true) || endsWith(configFilePath, '.split', true)))
+    throw new Error(`Invalid extension specified for feature flags mock file. Accepted extensions are ".yml" and ".yaml". Your specified file is ${configFilePath}`);
+
+  if (!fs.existsSync(configFilePath))
+    throw new Error(`Feature flags mock file not found in ${configFilePath} - Please review the file location.`);
+
+  return configFilePath;
+}
+
+// This function is not pure nor meant to be. Here we apply modifications to cover
+// for behavior that's ensured by the BE.
+function arrangeConditions(mocksData) {
+  // Iterate through each feature flag data
+  forOwn(mocksData, data => {
+    const conditions = data.conditions;
+
+    // On the manager, as feature flag JSONs come with all treatments on the partitions prop,
+    // we'll add all the treatments to the first condition.
+    const firstRolloutCondition = find(conditions, cond => cond.conditionType === 'ROLLOUT');
+    // Malformed mocks may have
+    const treatments = uniq(data.treatments);
+    // If they're only specifying a whitelist we add the treatments there.
+    const allTreatmentsCondition = firstRolloutCondition ? firstRolloutCondition : conditions[0];
+
+    const fullyAllocatedTreatment = allTreatmentsCondition.partitions[0].treatment;
+
+    treatments.forEach(treatment => {
+      if (treatment !== fullyAllocatedTreatment) {
+        allTreatmentsCondition.partitions.push({
+          treatment, size: 0
+        });
+      }
+    });
+
+    // Don't need these anymore
+    delete data.treatments;
+  });
+}
+
+export function splitsParserFromFileFactory() {
+
+  let previousMock = 'NO_MOCK_LOADED';
+
+  // Parse `.split` configuration file and return a map of feature flag objects
+  function readFeatureFlagConfigFile(log, filePath) {
+    const FEATURE_FLAG_POSITION = 0;
+    const TREATMENT_POSITION = 1;
+    let data;
+
+    try {
+      data = fs.readFileSync(filePath, 'utf-8');
+    } catch (e) {
+      log.error(e && e.message);
+
+      return {};
+    }
+
+    if (data === previousMock) return false;
+    previousMock = data;
+
+    const featureFlagObjects = data.split(/\r?\n/).reduce((accum, line, index) => {
+      let tuple = line.trim();
+
+      if (tuple === '' || tuple.charAt(0) === '#') {
+        log.debug(logPrefix + `Ignoring empty line or comment at #${index}`);
+      } else {
+        tuple = tuple.split(/\s+/);
+
+        if (tuple.length !== 2) {
+          log.debug(logPrefix + `Ignoring line since it does not have exactly two columns #${index}`);
+        } else {
+          const featureFlagName = tuple[FEATURE_FLAG_POSITION];
+          const condition = parseCondition({ treatment: tuple[TREATMENT_POSITION] });
+          accum[featureFlagName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
+        }
+      }
+
+      return accum;
+    }, {});
+
+    return featureFlagObjects;
+  }
+
+  // Parse `.yml` or `.yaml` configuration files and return a map of feature flag objects
+  function readYAMLConfigFile(log, filePath) {
+    let data = '';
+    let yamldoc = null;
+
+    try {
+      data = fs.readFileSync(filePath, 'utf8');
+
+      if (data === previousMock) return false;
+      previousMock = data;
+
+      yamldoc = yaml.safeLoad(data);
+    } catch (e) {
+      log.error(e);
+
+      return {};
+    }
+
+    // Each entry will be mapped to a condition, but we'll also keep the configurations map.
+    const mocksData = (yamldoc).reduce((accum, featureFlagEntry) => {
+      const featureFlagName = Object.keys(featureFlagEntry)[0];
+
+      if (!featureFlagName || !isString(featureFlagEntry[featureFlagName].treatment))
+        log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
+
+      const mockData = featureFlagEntry[featureFlagName];
+
+      // "Template" for each feature flag accumulated data
+      if (!accum[featureFlagName]) {
+        accum[featureFlagName] = {
+          configurations: {}, conditions: [], treatments: [], trafficTypeName: 'localhost'
+        };
+      }
+
+      // Assign the config if there is one on the mock
+      if (mockData.config) accum[featureFlagName].configurations[mockData.treatment] = mockData.config;
+      // Parse the condition from the entry.
+      const condition = parseCondition(mockData);
+      accum[featureFlagName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition);
+      // Also keep track of the treatments, will be useful for manager functionality.
+      accum[featureFlagName].treatments.push(mockData.treatment);
+
+      return accum;
+    }, {});
+
+    arrangeConditions(mocksData);
+
+    return mocksData;
+  }
+
+  // Load the content of a configuration file into an Object
+  return function featureFlagsParserFromFile({ features, log }) {
+    const filePath = configFilesPath(features);
+    let mockData;
+
+    // If we have a filePath, it means the extension is correct, choose the parser.
+    if (endsWith(filePath, '.split')) {
+      log.warn(logPrefix + '.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
+      mockData = readFeatureFlagConfigFile(log, filePath);
+    } else {
+      mockData = readYAMLConfigFile(log, filePath);
+    }
+
+    return mockData;
+  };
+
+}

package/src/umd.js

@@ -0,0 +1,4 @@
+import { SplitFactory } from './index';
+
+// eslint-disable-next-line import/no-default-export
+export default SplitFactory;

package/src/utils/ip.js

@@ -0,0 +1,123 @@
+/* eslint-disable no-redeclare */
+/*
+Trimmed version of "ip" package (https://www.npmjs.com/package/ip) that fixes an error when running in Node.js v18.
+
+This software is licensed under the MIT License.
+
+Copyright Fedor Indutny, 2012.
+
+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.
+*/
+import os from 'os';
+
+function _resolveFamily(family) {
+  return typeof family === 'number' ? 'ipv' + family : family.toLowerCase();
+}
+
+function _normalizeFamily(family) {
+  return family ? _resolveFamily(family) : 'ipv4';
+}
+
+function isPrivate(addr) {
+  return /^(::f{4}:)?10\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i
+    .test(addr) ||
+    /^(::f{4}:)?192\.168\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+    /^(::f{4}:)?172\.(1[6-9]|2\d|30|31)\.([0-9]{1,3})\.([0-9]{1,3})$/i
+      .test(addr) ||
+    /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+    /^(::f{4}:)?169\.254\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+    /^f[cd][0-9a-f]{2}:/i.test(addr) ||
+    /^fe80:/i.test(addr) ||
+    /^::1$/.test(addr) ||
+    /^::$/.test(addr);
+}
+
+function isPublic(addr) {
+  return !isPrivate(addr);
+}
+
+function isLoopback(addr) {
+  return /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/
+    .test(addr) ||
+    /^fe80::1$/.test(addr) ||
+    /^::1$/.test(addr) ||
+    /^::$/.test(addr);
+}
+
+function loopback(family) {
+  //
+  // Default to `ipv4`
+  //
+  family = _normalizeFamily(family);
+
+  if (family !== 'ipv4' && family !== 'ipv6') {
+    throw new Error('family must be ipv4 or ipv6');
+  }
+
+  return family === 'ipv4' ? '127.0.0.1' : 'fe80::1';
+}
+
+//
+// ### function address (name, family)
+// #### @name {string|'public'|'private'} **Optional** Name or security
+//      of the network interface.
+// #### @family {ipv4|ipv6} **Optional** IP family of the address (defaults
+//      to ipv4).
+//
+// Returns the address for the network interface on the current system with
+// the specified `name`:
+//   * String: First `family` address of the interface.
+//             If not found see `undefined`.
+//   * 'public': the first public ip address of family.
+//   * 'private': the first private ip address of family.
+//   * undefined: First address with `ipv4` or loopback address `127.0.0.1`.
+//
+export function address(name, family) {
+  var interfaces = os.networkInterfaces();
+  var all;
+
+  //
+  // Default to `ipv4`
+  //
+  family = _normalizeFamily(family);
+
+  //
+  // If a specific network interface has been named,
+  // return the address.
+  //
+  if (name && name !== 'private' && name !== 'public') {
+    var res = interfaces[name].filter(function (details) {
+      var itemFamily = _resolveFamily(details.family);
+      return itemFamily === family;
+    });
+    if (res.length === 0)
+      return undefined;
+    return res[0].address;
+  }
+
+  var all = Object.keys(interfaces).map(function (nic) {
+    //
+    // Note: name will only be `public` or `private`
+    // when this is called.
+    //
+    var addresses = interfaces[nic].filter(function (details) {
+      details.family = _resolveFamily(details.family);
+      if (details.family !== family || isLoopback(details.address)) {
+        return false;
+      } else if (!name) {
+        return true;
+      }
+
+      return name === 'public' ? isPrivate(details.address) :
+        isPublic(details.address);
+    });
+
+    return addresses.length ? addresses[0].address : undefined;
+  }).filter(Boolean);
+
+  return !all.length ? loopback(family) : all[0];
+}

package/types/client/index.d.ts

@@ -0,0 +1,15 @@
+// Declaration file for JavaScript Split Software SDK
+// Project: https://www.split.io/
+
+import '@splitsoftware/splitio-commons';
+
+export = JsSdk;
+
+declare module JsSdk {
+  /**
+   * Split.io SDK factory function.
+   * The settings parameter should be an object that complies with the SplitIO.IBrowserSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.IBrowserSDK;
+}

package/types/index.d.ts

@@ -1,5 +1,28 @@
-// Declaration file for JavaScript Browser Split Software SDK
+// Declaration file for JavaScript and Node.js Split Software SDK v8.1.0
 // Project: https://www.split.io/
 // Definitions by: Nico Zelaya <https://github.com/NicoZelaya/>
 
 /// <reference path="./splitio.d.ts" />
+
+export = JsSdk;
+
+declare module JsSdk {
+  /**
+   * Split.io SDK factory function.
+   * The settings parameter should be an object that complies with the SplitIO.INodeAsyncSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.INodeAsyncSettings): SplitIO.IAsyncSDK;
+  /**
+   * Split.io SDK factory function.
+   * The settings parameter should be an object that complies with the SplitIO.INodeSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.INodeSettings): SplitIO.ISDK;
+  /**
+   * Split.io SDK factory function.
+   * The settings parameter should be an object that complies with the SplitIO.IBrowserSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.IBrowserSDK;
+}

package/types/server/index.d.ts

@@ -0,0 +1,21 @@
+// Declaration file for JavaScript Split Software SDK
+// Project: https://www.split.io/
+
+import '@splitsoftware/splitio-commons';
+
+export = JsSdk;
+
+declare module JsSdk {
+  /**
+   * Split.io SDK factory function.
+   * The settings parameter should be an object that complies with the SplitIO.INodeAsyncSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.INodeAsyncSettings): SplitIO.IAsyncSDK;
+  /**
+   * Split.io SDK factory function.
+   * The settings parameter should be an object that complies with the SplitIO.INodeSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.INodeSettings): SplitIO.ISDK;
+}