refactor: simplify input validation for the case where the SDK is not operational

Author: EmilianoSanchez

CHANGES.txt

@@ -1,3 +1,8 @@
+2.6.0 (October XX, 2025)
+ - Updated @splitsoftware/splitio package to version 11.7.1 that includes minor updates:
+      - Added support for custom loggers: added `logger` configuration option and `factory.Logger.setLogger` method to allow the SDK to use a custom logger.
+
+
 2.5.0 (September 18, 2025)
  - Updated @splitsoftware/splitio package to version 11.6.0 that includes minor updates:
       - Added `storage.wrapper` configuration option to allow the SDK to use a custom storage wrapper for the storage type `LOCALSTORAGE`. Default value is `window.localStorage`.

package-lock.json

@@ -63,7 +63,7 @@
   },
   "homepage": "https://github.com/splitio/react-client#readme",
   "dependencies": {
-    "@splitsoftware/splitio": "11.6.1-rc.1",
+    "@splitsoftware/splitio": "11.7.1",
     "memoize-one": "^5.1.1",
     "shallowequal": "^1.1.0",
     "tslib": "^2.3.1"

package.json

@@ -19,15 +19,11 @@ import { SplitClient } from '../SplitClient';
 import { SplitFactoryProvider } from '../SplitFactoryProvider';
 import { useSplitTreatments } from '../useSplitTreatments';
 
-const logSpy = jest.spyOn(console, 'log');
-
 describe('SplitTreatments', () => {
 
   const featureFlagNames = ['split1', 'split2'];
   const flagSets = ['set1', 'set2'];
 
-  afterEach(() => { logSpy.mockClear() });
-
   it('passes control treatments (empty object if flagSets is provided) if the SDK is not operational.', () => {
     render(
       <SplitFactoryProvider config={sdkBrowser} >
@@ -105,10 +101,9 @@ describe('SplitTreatments', () => {
   });
 
   /**
-   * Input validation. Passing invalid feature flag names or attributes while the Sdk
-   * is not ready doesn't emit errors, and logs meaningful messages instead.
+   * Input validation: sanitize invalid feature flag names and return control while the SDK is not ready.
    */
-  it('Input validation: invalid "names" and "attributes" props in SplitTreatments.', (done) => {
+  it('Input validation: invalid names are sanitized.', () => {
     render(
       <SplitFactoryProvider config={sdkBrowser} >
         <SplitClient>
@@ -130,9 +125,9 @@ describe('SplitTreatments', () => {
                   }}
                 </SplitTreatments>
                 {/* @ts-expect-error Test error handling */}
-                <SplitTreatments names={[true]} attributes={'invalid'} >
+                <SplitTreatments names={[true, ' flag_1 ', ' ']} >
                   {({ treatments }: ISplitTreatmentsChildProps) => {
-                    expect(treatments).toEqual({});
+                    expect(treatments).toEqual({ flag_1: CONTROL_WITH_CONFIG });
                     return null;
                   }}
                 </SplitTreatments>
@@ -142,14 +137,9 @@ describe('SplitTreatments', () => {
         </SplitClient>
       </SplitFactoryProvider>
     );
-    expect(logSpy).toBeCalledWith('[ERROR] splitio => feature flag names must be a non-empty array.');
-    expect(logSpy).toBeCalledWith('[ERROR] splitio => you passed an invalid feature flag name, feature flag name must be a non-empty string.');
-
-    done();
   });
 
-
-  test('ignores flagSets and logs a warning if both names and flagSets params are provided.', () => {
+  test('ignores flagSets if both names and flagSets params are provided.', () => {
     render(
       <SplitFactoryProvider >
         {/* @ts-expect-error flagSets and names are mutually exclusive */}
@@ -161,8 +151,6 @@ describe('SplitTreatments', () => {
         </SplitTreatments>
       </SplitFactoryProvider>
     );
-
-    expect(logSpy).toBeCalledWith('[WARN]  splitio => Both names and flagSets properties were provided. flagSets will be ignored.');
   });
 
   test('returns the treatments from the client at Split context updated by SplitClient, or control if the client is not operational.', async () => {
@@ -190,7 +178,7 @@ describe('SplitTreatments', () => {
     act(() => client.__emitter__.emit(Event.SDK_READY_FROM_CACHE));
 
     expect(client.getTreatmentsWithConfig).toBeCalledWith(featureFlagNames, attributes, undefined);
-    expect(client.getTreatmentsWithConfig).toHaveReturnedWith(treatments);
+    expect(client.getTreatmentsWithConfig).toHaveReturnedWith(treatments!);
   });
 });
 

src/__tests__/SplitTreatments.test.tsx

@@ -1,7 +1,6 @@
 import { EventEmitter } from 'events';
 import jsSdkPackageJson from '@splitsoftware/splitio/package.json';
 import reactSdkPackageJson from '../../../package.json';
-import { DEFAULT_LOGGER } from '../../utils';
 
 export const jsSdkVersion = `javascript-${jsSdkPackageJson.version}`;
 export const reactSdkVersion = `react-${reactSdkPackageJson.version}`;
@@ -13,6 +12,13 @@ export const Event = {
   SDK_UPDATE: 'state::update',
 };
 
+const DEFAULT_LOGGER: SplitIO.Logger = {
+  error(msg) { console.log('[ERROR] splitio => ' + msg); },
+  warn(msg) { console.log('[WARN]  splitio => ' + msg); },
+  info(msg) { console.log('[INFO]  splitio => ' + msg); },
+  debug(msg) { console.log('[DEBUG] splitio => ' + msg); },
+};
+
 function parseKey(key: SplitIO.SplitKey): SplitIO.SplitKey {
   if (key && typeof key === 'object' && key.constructor === Object) {
     return {

src/__tests__/testUtils/mockSplitFactory.ts

@@ -16,8 +16,6 @@ import { useSplitTreatments } from '../useSplitTreatments';
 import { SplitContext } from '../SplitContext';
 import { ISplitTreatmentsChildProps } from '../types';
 
-const logSpy = jest.spyOn(console, 'log');
-
 describe('useSplitTreatments', () => {
 
   const featureFlagNames = ['split1'];
@@ -56,10 +54,10 @@ describe('useSplitTreatments', () => {
     act(() => client.__emitter__.emit(Event.SDK_READY));
 
     expect(client.getTreatmentsWithConfig).toBeCalledWith(featureFlagNames, attributes, { properties });
-    expect(client.getTreatmentsWithConfig).toHaveReturnedWith(treatments);
+    expect(client.getTreatmentsWithConfig).toHaveReturnedWith(treatments!);
 
     expect(client.getTreatmentsWithConfigByFlagSets).toBeCalledWith(flagSets, attributes, { properties });
-    expect(client.getTreatmentsWithConfigByFlagSets).toHaveReturnedWith(treatmentsByFlagSets);
+    expect(client.getTreatmentsWithConfigByFlagSets).toHaveReturnedWith(treatmentsByFlagSets!);
   });
 
   test('returns the treatments from a new client given a splitKey, and re-evaluates on SDK events.', () => {
@@ -113,10 +111,9 @@ describe('useSplitTreatments', () => {
   });
 
   /**
-   * Input validation. Passing invalid feature flag names or attributes while the Sdk
-   * is not ready doesn't emit errors, and logs meaningful messages instead.
+   * Input validation: sanitize invalid feature flag names and return control while the SDK is not ready.
    */
-  test('Input validation: invalid "names" and "attributes" params in useSplitTreatments.', () => {
+  test('Input validation: invalid names are sanitized.', () => {
     render(
       <SplitFactoryProvider >
         {
@@ -125,16 +122,14 @@ describe('useSplitTreatments', () => {
             let treatments = useSplitTreatments('split1').treatments;
             expect(treatments).toEqual({});
             // @ts-expect-error Test error handling
-            treatments = useSplitTreatments({ names: [true] }).treatments;
-            expect(treatments).toEqual({});
+            treatments = useSplitTreatments({ names: [true, ' flag_1 ', ' '] }).treatments;
+            expect(treatments).toEqual({ flag_1: CONTROL_WITH_CONFIG });
 
             return null;
           })
         }
       </SplitFactoryProvider>
     );
-    expect(logSpy).toBeCalledWith('[ERROR] splitio => feature flag names must be a non-empty array.');
-    expect(logSpy).toBeCalledWith('[ERROR] splitio => you passed an invalid feature flag name, feature flag name must be a non-empty string.');
   });
 
   test('useSplitTreatments must update on SDK events', async () => {
@@ -222,7 +217,7 @@ describe('useSplitTreatments', () => {
     expect(user2Client.getTreatmentsWithConfig).toHaveBeenLastCalledWith(['split_test'], undefined, undefined);
   });
 
-  test('ignores flagSets and logs a warning if both names and flagSets params are provided.', () => {
+  test('ignores flagSets if both names and flagSets params are provided.', () => {
     render(
       <SplitFactoryProvider >
         {
@@ -235,8 +230,6 @@ describe('useSplitTreatments', () => {
         }
       </SplitFactoryProvider>
     );
-
-    expect(logSpy).toHaveBeenLastCalledWith('[WARN]  splitio => Both names and flagSets properties were provided. flagSets will be ignored.');
   });
 
 });

src/__tests__/useSplitTreatments.test.tsx

@@ -1,15 +1,15 @@
 import { CONTROL_WITH_CONFIG } from '../constants';
-import { DEFAULT_LOGGER, getControlTreatmentsWithConfig } from '../utils';
+import { getControlTreatmentsWithConfig } from '../utils';
 
 describe('getControlTreatmentsWithConfig', () => {
 
   it('should return an empty object if an empty array is provided', () => {
-    expect(Object.values(getControlTreatmentsWithConfig(DEFAULT_LOGGER, [])).length).toBe(0);
+    expect(Object.values(getControlTreatmentsWithConfig([])).length).toBe(0);
   });
 
   it('should return an empty object if an empty array is provided', () => {
     const featureFlagNames = ['split1', 'split2'];
-    const treatments: SplitIO.TreatmentsWithConfig = getControlTreatmentsWithConfig(DEFAULT_LOGGER, featureFlagNames);
+    const treatments: SplitIO.TreatmentsWithConfig = getControlTreatmentsWithConfig(featureFlagNames);
     featureFlagNames.forEach((featureFlagName) => {
       expect(treatments[featureFlagName]).toBe(CONTROL_WITH_CONFIG);
     });

src/__tests__/utils.test.ts

@@ -14,7 +14,7 @@ import { INITIAL_STATUS } from './testUtils/utils';
 import { withSplitFactory } from '../withSplitFactory';
 import { withSplitClient } from '../withSplitClient';
 import { withSplitTreatments } from '../withSplitTreatments';
-import { DEFAULT_LOGGER, getControlTreatmentsWithConfig } from '../utils';
+import { getControlTreatmentsWithConfig } from '../utils';
 
 const featureFlagNames = ['split1', 'split2'];
 
@@ -36,7 +36,7 @@ describe('withSplitTreatments', () => {
                 ...INITIAL_STATUS,
                 factory: factory, client: clientMock,
                 outerProp1: 'outerProp1', outerProp2: 2,
-                treatments: getControlTreatmentsWithConfig(DEFAULT_LOGGER, featureFlagNames),
+                treatments: getControlTreatmentsWithConfig(featureFlagNames),
               });
 
               return null;

src/__tests__/withSplitTreatments.test.tsx

@@ -17,5 +17,3 @@ export const CONTROL_WITH_CONFIG: SplitIO.TreatmentWithConfig = {
 export const WARN_SF_CONFIG_AND_FACTORY: string = 'Both a config and factory props were provided to SplitFactoryProvider. Config prop will be ignored.';
 
 export const EXCEPTION_NO_SFP: string = 'No SplitContext was set. Please ensure the component is wrapped in a SplitFactoryProvider.';
-
-export const WARN_NAMES_AND_FLAGSETS: string = 'Both names and flagSets properties were provided. flagSets will be ignored.';

src/constants.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { memoizeGetTreatmentsWithConfig, DEFAULT_LOGGER } from './utils';
+import { memoizeGetTreatmentsWithConfig } from './utils';
 import { ISplitTreatmentsChildProps, IUseSplitTreatmentsOptions } from './types';
 import { useSplitClient } from './useSplitClient';
 
@@ -20,14 +20,14 @@ import { useSplitClient } from './useSplitClient';
  */
 export function useSplitTreatments(options: IUseSplitTreatmentsOptions): ISplitTreatmentsChildProps {
   const context = useSplitClient({ ...options, attributes: undefined });
-  const { factory, client, lastUpdate } = context;
+  const { client, lastUpdate } = context;
   const { names, flagSets, attributes, properties } = options;
 
   const getTreatmentsWithConfig = React.useMemo(memoizeGetTreatmentsWithConfig, []);
 
   // Shallow copy `client.getAttributes` result for memoization, as it returns the same reference unless `client.clearAttributes` is invoked.
   // Note: the same issue occurs with the `names` and `attributes` arguments if they are mutated directly by the user instead of providing a new object.
-  const treatments = getTreatmentsWithConfig(factory ? (factory.settings as any).log : DEFAULT_LOGGER, client, lastUpdate, names, attributes, client ? { ...client.getAttributes() } : {}, flagSets, properties && { properties });
+  const treatments = getTreatmentsWithConfig(client, lastUpdate, names, attributes, client ? { ...client.getAttributes() } : {}, flagSets, properties && { properties });
 
   return {
     ...context,