feat: Add configuration validation for ReactNative specific configuration. (#532)

Author: kinyoklion

packages/sdk/react-native/src/RNOptions.ts

@@ -1,6 +1,6 @@
 import { LDOptions } from '@launchdarkly/js-client-sdk-common';
 
-export default interface RNOptions extends LDOptions {
+export interface RNSpecificOptions {
   /**
    * Some platforms (windows, web, mac, linux) can continue executing code
    * in the background.
@@ -26,3 +26,5 @@ export default interface RNOptions extends LDOptions {
    */
   readonly automaticBackgroundHandling?: boolean;
 }
+
+export default interface RNOptions extends LDOptions, RNSpecificOptions {}

packages/sdk/react-native/src/ReactNativeLDClient.ts

@@ -9,6 +9,7 @@ import {
   type LDContext,
 } from '@launchdarkly/js-client-sdk-common';
 
+import validateOptions, { filterToBaseOptions } from './options';
 import createPlatform from './platform';
 import { ConnectionDestination, ConnectionManager } from './platform/ConnectionManager';
 import LDOptions from './RNOptions';
@@ -59,7 +60,7 @@ export default class ReactNativeLDClient extends LDClientImpl {
       sdkKey,
       autoEnvAttributes,
       createPlatform(logger),
-      { ...options, logger },
+      { ...filterToBaseOptions(options), logger },
       internalOptions,
     );
 
@@ -77,17 +78,15 @@ export default class ReactNativeLDClient extends LDClientImpl {
       },
     };
 
+    const validatedRnOptions = validateOptions(options, logger);
     const initialConnectionMode = options.initialConnectionMode ?? 'streaming';
     this.connectionManager = new ConnectionManager(
       logger,
       {
         initialConnectionMode,
-        // TODO: Add the ability to configure connection management.
-        // This is not yet added as the RN SDK needs package specific configuration added.
-        // TODO: Add RN config option validation beyond base options.
-        automaticNetworkHandling: options.automaticNetworkHandling ?? true,
-        automaticBackgroundHandling: options.automaticBackgroundHandling ?? true,
-        runInBackground: options.runInBackground ?? true,
+        automaticNetworkHandling: validatedRnOptions.automaticNetworkHandling,
+        automaticBackgroundHandling: validatedRnOptions.automaticBackgroundHandling,
+        runInBackground: validatedRnOptions.runInBackground,
       },
       destination,
       new RNStateDetector(),

packages/sdk/react-native/src/options.test.ts

@@ -0,0 +1,101 @@
+import { LDLogger } from '@launchdarkly/js-client-sdk-common';
+
+import validateOptions, { filterToBaseOptions } from './options';
+
+it('logs no warnings when all configuration is valid', () => {
+  const logger: LDLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  };
+
+  validateOptions(
+    {
+      runInBackground: true,
+      automaticBackgroundHandling: true,
+      automaticNetworkHandling: true,
+    },
+    logger,
+  );
+
+  expect(logger.debug).not.toHaveBeenCalled();
+  expect(logger.info).not.toHaveBeenCalled();
+  expect(logger.warn).not.toHaveBeenCalled();
+  expect(logger.error).not.toHaveBeenCalled();
+});
+
+it('warns for invalid configuration', () => {
+  const logger: LDLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  };
+
+  validateOptions(
+    {
+      // @ts-ignore
+      runInBackground: 'toast',
+      // @ts-ignore
+      automaticBackgroundHandling: 42,
+      // @ts-ignore
+      automaticNetworkHandling: {},
+    },
+    logger,
+  );
+
+  expect(logger.warn).toHaveBeenCalledTimes(3);
+  expect(logger.warn).toHaveBeenCalledWith(
+    'Config option "runInBackground" should be of type boolean, got string, using default value',
+  );
+  expect(logger.warn).toHaveBeenCalledWith(
+    'Config option "automaticBackgroundHandling" should be of type boolean, got number, using default value',
+  );
+  expect(logger.warn).toHaveBeenCalledWith(
+    'Config option "automaticNetworkHandling" should be of type boolean, got object, using default value',
+  );
+});
+
+it('applies default options', () => {
+  const logger: LDLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  };
+  const opts = validateOptions({}, logger);
+
+  expect(opts.runInBackground).toBe(false);
+  expect(opts.automaticBackgroundHandling).toBe(true);
+  expect(opts.automaticNetworkHandling).toBe(true);
+
+  expect(logger.debug).not.toHaveBeenCalled();
+  expect(logger.info).not.toHaveBeenCalled();
+  expect(logger.warn).not.toHaveBeenCalled();
+  expect(logger.error).not.toHaveBeenCalled();
+});
+
+it('filters to base options', () => {
+  const logger: LDLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  };
+  const opts = {
+    debug: false,
+    runInBackground: true,
+    automaticBackgroundHandling: true,
+    automaticNetworkHandling: true,
+  };
+
+  const baseOpts = filterToBaseOptions(opts);
+  expect(baseOpts.debug).toBe(false);
+  expect(Object.keys(baseOpts).length).toEqual(1);
+
+  expect(logger.debug).not.toHaveBeenCalled();
+  expect(logger.info).not.toHaveBeenCalled();
+  expect(logger.warn).not.toHaveBeenCalled();
+  expect(logger.error).not.toHaveBeenCalled();
+});

packages/sdk/react-native/src/options.ts

@@ -0,0 +1,56 @@
+import {
+  LDLogger,
+  LDOptions,
+  OptionMessages,
+  TypeValidator,
+  TypeValidators,
+} from '@launchdarkly/js-client-sdk-common';
+
+import RNOptions from './RNOptions';
+
+export interface ValidatedOptions {
+  runInBackground: boolean;
+  automaticNetworkHandling: boolean;
+  automaticBackgroundHandling: boolean;
+}
+
+const optDefaults = {
+  runInBackground: false,
+  automaticNetworkHandling: true,
+  automaticBackgroundHandling: true,
+};
+
+const validators: { [Property in keyof RNOptions]: TypeValidator | undefined } = {
+  runInBackground: TypeValidators.Boolean,
+  automaticNetworkHandling: TypeValidators.Boolean,
+  automaticBackgroundHandling: TypeValidators.Boolean,
+};
+
+export function filterToBaseOptions(opts: RNOptions): LDOptions {
+  const baseOptions: LDOptions = { ...opts };
+
+  // Remove any RN specific configuration keys so we don't get warnings from
+  // the base implementation for unknown configuration.
+  Object.keys(optDefaults).forEach((key) => {
+    delete (baseOptions as any)[key];
+  });
+  return baseOptions;
+}
+
+export default function validateOptions(opts: RNOptions, logger: LDLogger): ValidatedOptions {
+  const output: ValidatedOptions = { ...optDefaults };
+
+  Object.entries(validators).forEach((entry) => {
+    const [key, validator] = entry as [keyof RNOptions, TypeValidator];
+    const value = opts[key];
+    if (value !== undefined) {
+      if (validator.is(value)) {
+        output[key as keyof ValidatedOptions] = value as any;
+      } else {
+        logger.warn(OptionMessages.wrongOptionType(key, validator.getType(), typeof value));
+      }
+    }
+  });
+
+  return output;
+}