Merge pull request #314 from splitio/update_imports_to_support_mjs

Update internal import of `ioredis` to support bundling the SDK into .mjs files

Author: EmilianoSanchez

CHANGES.txt

@@ -1,5 +1,8 @@
-1.15.1 (May 28, 2024)
+1.16.0 (June 13, 2024)
+ - Added the `getOptions` method to the `IPlatform` interface to allow the SDK to pass request options to the `fetch` function and `EventSource` constructor when fetching data from the Split servers. The method is optional and, if provided, it is called twice: first for the `fetch` options and then for the `EventSource` options. Useful for advanced use cases like configuring a proxy or validating HTTPS certificates in NodeJS.
+ - Updated the Redis storage to lazily import the `ioredis` dependency when the storage is created. This prevents errors when the SDK is imported or bundled in a .mjs file, as `ioredis` is a CommonJS module.
  - Bugfixing - Restored some input validation error logs that were removed in version 1.12.0. The logs inform the user when the `getTreatment(s)` methods are called with an invalid value as feature flag name or flag set name.
+ - Bugfixing - Fixed localhost mode to emit SDK_UPDATE when mocked feature flags are updated in the `features` object map of the config object (Related to issue https://github.com/splitio/javascript-browser-client/issues/119).
 
 1.15.0 (May 13, 2024)
  - Added an optional settings validation parameter to let overwrite the default flag spec version, used by the JS Synchronizer.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.15.1-rc.0",
+  "version": "1.16.0",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package.json

@@ -49,6 +49,7 @@ const fullParamsForSyncSDK = {
   platform: {
     getEventSource: jest.fn(),
     getFetch: jest.fn(),
+    getOptions: jest.fn(),
     EventEmitter
   },
   splitApiFactory: jest.fn(),

src/sdkFactory/__tests__/index.spec.ts

@@ -17,11 +17,15 @@ export interface IPlatform {
   /**
    * If provided, it is used to retrieve the Fetch API for HTTP requests. Otherwise, the global fetch is used.
    */
-  getFetch?: () => (IFetch | undefined)
+  getFetch?: (settings: ISettings) => (IFetch | undefined)
+  /**
+   * If provided, it is used to pass additional options to fetch and eventsource calls.
+   */
+  getOptions?: (settings: ISettings) => object
   /**
    * If provided, it is used to retrieve the EventSource constructor for streaming support.
    */
-  getEventSource?: () => (IEventSourceConstructor | undefined)
+  getEventSource?: (settings: ISettings) => (IEventSourceConstructor | undefined)
   /**
    * EventEmitter constructor, like NodeJS.EventEmitter or a polyfill.
    */

src/sdkFactory/types.ts

@@ -22,15 +22,15 @@ function userKeyToQueryParam(userKey: string) {
  */
 export function splitApiFactory(
   settings: ISettings,
-  platform: Pick<IPlatform, 'getFetch'>,
+  platform: IPlatform,
   telemetryTracker: ITelemetryTracker
 ): ISplitApi {
 
   const urls = settings.urls;
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
   const flagSpecVersion = settings.sync.flagSpecVersion;
-  const splitHttpClient = splitHttpClientFactory(settings, platform.getFetch);
+  const splitHttpClient = splitHttpClientFactory(settings, platform);
 
   return {
     // @TODO throw errors if health check requests fail, to log them in the Synchronizer

src/services/splitApi.ts

@@ -10,12 +10,13 @@ const messageNoFetch = 'Global fetch API is not available.';
  * Factory of Split HTTP clients, which are HTTP clients with predefined headers for Split endpoints.
  *
  * @param settings SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers
- * @param getFetch retrieves the Fetch API for HTTP requests
+ * @param platform object containing environment-specific dependencies
  */
-export function splitHttpClientFactory(settings: ISettings, getFetch?: IPlatform['getFetch']): ISplitHttpClient {
+export function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient {
 
   const { log, core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
-  const fetch = getFetch && getFetch();
+  const options = getOptions && getOptions(settings);
+  const fetch = getFetch && getFetch(settings);
 
   // if fetch is not available, log Error
   if (!fetch) log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
@@ -32,11 +33,11 @@ export function splitHttpClientFactory(settings: ISettings, getFetch?: IPlatform
 
   return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo: boolean = false): Promise<IResponse> {
 
-    const request = {
+    const request = objectAssign({
       headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,
       method: reqOpts.method || 'GET',
       body: reqOpts.body
-    };
+    }, options);
 
     // using `fetch(url, options)` signature to work with unfetch, a lightweight ponyfill of fetch API.
     return fetch ? fetch(url, request)

src/services/splitHttpClient.ts

@@ -1,4 +1,4 @@
-import { RedisAdapter } from './RedisAdapter';
+import type { RedisAdapter } from './RedisAdapter';
 import { IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
@@ -23,13 +23,17 @@ export interface InRedisStorageOptions {
  */
 export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsyncFactory {
 
+  // Lazy loading to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
+  // Redis storage is not supported with .mjs files.
+  const RD = require('./RedisAdapter').RedisAdapter;
+
   const prefix = validatePrefix(options.prefix);
 
   function InRedisStorageFactory(params: IStorageFactoryParams): IStorageAsync {
     const { onReadyCb, settings, settings: { log, sync: { impressionsMode } } } = params;
     const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
-    const redisClient = new RedisAdapter(log, options.options || {});
+    const redisClient: RedisAdapter = new RD(log, options.options || {});
     const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
     const impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
     const uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;

src/storages/inRedis/index.ts

@@ -0,0 +1,50 @@
+import { SplitIO } from '../../../../types';
+import { splitsParserFromSettingsFactory } from '../splitsParserFromSettings';
+
+const FEATURE_ON = { conditions: [{ conditionType: 'ROLLOUT', label: 'default rule', matcherGroup: { combiner: 'AND', matchers: [{ keySelector: null, matcherType: 'ALL_KEYS', negate: false }] }, partitions: [{ size: 100, treatment: 'on' }] }], configurations: {}, trafficTypeName: 'localhost' };
+const FEATURE_OFF = { conditions: [{ conditionType: 'ROLLOUT', label: 'default rule', matcherGroup: { combiner: 'AND', matchers: [{ keySelector: null, matcherType: 'ALL_KEYS', negate: false }] }, partitions: [{ size: 100, treatment: 'off' }] }], configurations: {}, trafficTypeName: 'localhost' };
+
+test('splitsParserFromSettingsFactory', () => {
+
+  const instance = splitsParserFromSettingsFactory();
+
+  const settings = { features: {} as SplitIO.MockedFeaturesMap };
+  expect(instance(settings)).toEqual({});
+
+  // Pass the same settings
+  expect(instance(settings)).toEqual(false);
+
+  // New features object with new content
+  settings.features = { feature1: 'on' };
+  expect(instance(settings)).toEqual({ feature1: FEATURE_ON });
+
+  // New features object but same content
+  settings.features = { feature1: 'on' };
+  expect(instance(settings)).toEqual(false);
+
+  // Update property
+  settings.features['feature1'] = 'off';
+  expect(instance(settings)).toEqual({ feature1: FEATURE_OFF });
+
+  // New settings object but same content
+  expect(instance({ features: { feature1: 'off' } })).toEqual(false);
+
+  // Update property. Same content but in a different format
+  settings.features['feature1'] = { treatment: 'off', config: null };
+  expect(instance(settings)).toEqual({ feature1: FEATURE_OFF });
+
+  // Add new feature flag property
+  settings.features['feature2'] = { treatment: 'on', config: null };
+  expect(instance(settings)).toEqual({ feature1: FEATURE_OFF, feature2: FEATURE_ON });
+
+  // New settings object but same content
+  expect(instance({ features: { feature1: { treatment: 'off', config: null }, feature2: { treatment: 'on', config: null } } })).toEqual(false);
+
+  // Update property
+  settings.features['feature2'].config = 'some_config';
+  expect(instance(settings)).toEqual({ feature1: FEATURE_OFF, feature2: { ...FEATURE_ON, configurations: { on: 'some_config' } } });
+
+  // @ts-expect-error No object implies no features
+  settings.features = undefined;
+  expect(instance(settings)).toEqual({});
+});

src/sync/offline/splitsParser/__tests__/splitsParserFromSettings.spec.ts

@@ -1,6 +1,6 @@
 import { ISplitPartial } from '../../../dtos/types';
 import { ISettings, SplitIO } from '../../../types';
-import { isObject, forOwn } from '../../../utils/lang';
+import { isObject, forOwn, merge } from '../../../utils/lang';
 import { parseCondition } from './parseCondition';
 
 function hasTreatmentChanged(prev: string | SplitIO.TreatmentWithConfig, curr: string | SplitIO.TreatmentWithConfig) {
@@ -22,7 +22,7 @@ export function splitsParserFromSettingsFactory() {
 
     // Different amount of items
     if (names.length !== Object.keys(previousMock).length) {
-      previousMock = currentData;
+      previousMock = merge({}, currentData) as SplitIO.MockedFeaturesMap;
       return true;
     }
 
@@ -31,7 +31,7 @@ export function splitsParserFromSettingsFactory() {
       const newTreatment = hasTreatmentChanged(previousMock[name], currentData[name]);
       const changed = newSplit || newTreatment;
 
-      if (changed) previousMock = currentData;
+      if (changed) previousMock = merge({}, currentData) as SplitIO.MockedFeaturesMap;
 
       return changed;
     });
@@ -41,7 +41,7 @@ export function splitsParserFromSettingsFactory() {
    *
    * @param settings validated object with mocked features mapping.
    */
-  return function splitsParserFromSettings(settings: ISettings): false | Record<string, ISplitPartial> {
+  return function splitsParserFromSettings(settings: Pick<ISettings, 'features'>): false | Record<string, ISplitPartial> {
     const features = settings.features as SplitIO.MockedFeaturesMap || {};
 
     if (!mockUpdated(features)) return false;