Refactor config validation.

Author: kinyoklion

packages/sdk/browser/src/BrowserClient.ts

@@ -4,11 +4,9 @@ import {
   BROWSER_DATA_SYSTEM_DEFAULTS,
   browserFdv1Endpoints,
   Configuration,
-  dataSystemValidators,
   FlagManager,
   Hook,
   internal,
-  LDClientDataSystemOptions,
   LDClientImpl,
   LDContext,
   LDEmitter,
@@ -22,7 +20,6 @@ import {
   Platform,
   readFlagsFromBootstrap,
   safeRegisterDebugOverridePlugins,
-  validateOptions,
 } from '@launchdarkly/js-client-sdk-common';
 
 import { getHref } from './BrowserApi';
@@ -82,53 +79,34 @@ class BrowserClientImpl extends LDClientImpl {
     const { eventUrlTransformer } = validatedBrowserOptions;
     const endpoints = browserFdv1Endpoints(clientSideId);
 
-    const validatedDataSystem =
-      options.dataSystem !== undefined
-        ? (validateOptions(
-            options.dataSystem,
-            dataSystemValidators,
-            BROWSER_DATA_SYSTEM_DEFAULTS as unknown as Record<string, unknown>,
-            logger,
-            'dataSystem',
-          ) as unknown as LDClientDataSystemOptions)
-        : undefined;
-
-    const dataManagerFactory =
-      validatedDataSystem !== undefined
-        ? (
-            flagManager: FlagManager,
-            configuration: Configuration,
-            baseHeaders: LDHeaders,
-            emitter: LDEmitter,
-            _diagnosticsManager?: internal.DiagnosticsManager,
-          ) =>
-            new BrowserFDv2DataManager(
-              platform,
-              flagManager,
-              clientSideId,
-              configuration,
-              baseHeaders,
-              emitter,
-            )
-        : (
-            flagManager: FlagManager,
-            configuration: Configuration,
-            baseHeaders: LDHeaders,
-            emitter: LDEmitter,
-            diagnosticsManager?: internal.DiagnosticsManager,
-          ) =>
-            new BrowserDataManager(
-              platform,
-              flagManager,
-              clientSideId,
-              configuration,
-              validatedBrowserOptions,
-              endpoints.polling,
-              endpoints.streaming,
-              baseHeaders,
-              emitter,
-              diagnosticsManager,
-            );
+    const dataManagerFactory = (
+      flagManager: FlagManager,
+      configuration: Configuration,
+      baseHeaders: LDHeaders,
+      emitter: LDEmitter,
+      diagnosticsManager?: internal.DiagnosticsManager,
+    ) =>
+      configuration.dataSystem
+        ? new BrowserFDv2DataManager(
+            platform,
+            flagManager,
+            clientSideId,
+            configuration,
+            baseHeaders,
+            emitter,
+          )
+        : new BrowserDataManager(
+            platform,
+            flagManager,
+            clientSideId,
+            configuration,
+            validatedBrowserOptions,
+            endpoints.polling,
+            endpoints.streaming,
+            baseHeaders,
+            emitter,
+            diagnosticsManager,
+          );
 
     super(clientSideId, autoEnvAttributes, platform, baseOptionsWithDefaults, dataManagerFactory, {
       // This logic is derived from https://github.com/launchdarkly/js-sdk-common/blob/main/src/PersistentFlagStore.js
@@ -139,6 +117,7 @@ class BrowserClientImpl extends LDClientImpl {
       includeAuthorizationHeader: false,
       highTimeoutThreshold: 5,
       userAgentHeaderName: 'x-launchdarkly-user-agent',
+      dataSystemDefaults: BROWSER_DATA_SYSTEM_DEFAULTS,
       trackEventModifier: (event: internal.InputCustomEvent) =>
         new internal.InputCustomEvent(
           event.context,

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

@@ -11,6 +11,7 @@ import {
   LDEmitter,
   LDHeaders,
   LDPluginEnvironmentMetadata,
+  MOBILE_DATA_SYSTEM_DEFAULTS,
   mobileFdv1Endpoints,
 } from '@launchdarkly/js-client-sdk-common';
 
@@ -65,6 +66,7 @@ export default class ReactNativeLDClient extends LDClientImpl {
       getImplementationHooks: (_environmentMetadata: LDPluginEnvironmentMetadata) =>
         internal.safeGetHooks(logger, _environmentMetadata, validatedRnOptions.plugins),
       credentialType: 'mobileKey',
+      dataSystemDefaults: MOBILE_DATA_SYSTEM_DEFAULTS,
     };
 
     const platform = createPlatform(logger, options, validatedRnOptions.storage);

packages/shared/sdk-client/__tests__/configuration/Configuration.test.ts

@@ -178,3 +178,92 @@ it('does not wrap already safe loggers', () => {
   const config = new ConfigurationImpl({ logger });
   expect(config.logger).toBe(logger);
 });
+
+describe('dataSystem validation', () => {
+  it('does not set dataSystem when not provided', () => {
+    const config = new ConfigurationImpl(
+      {},
+      {
+        getImplementationHooks: () => [],
+        credentialType: 'clientSideId',
+        dataSystemDefaults: {
+          initialConnectionMode: 'one-shot',
+          automaticModeSwitching: false,
+        },
+      },
+    );
+    expect(config.dataSystem).toBeUndefined();
+  });
+
+  it('validates dataSystem with platform defaults when provided as empty object', () => {
+    const config = new ConfigurationImpl(
+      // @ts-ignore dataSystem is @internal
+      { dataSystem: {} },
+      {
+        getImplementationHooks: () => [],
+        credentialType: 'clientSideId',
+        dataSystemDefaults: {
+          initialConnectionMode: 'one-shot',
+          automaticModeSwitching: false,
+        },
+      },
+    );
+    expect(config.dataSystem).toBeDefined();
+    expect(config.dataSystem!.initialConnectionMode).toBe('one-shot');
+    expect(config.dataSystem!.automaticModeSwitching).toBe(false);
+  });
+
+  it('validates dataSystem with user overrides applied over platform defaults', () => {
+    const config = new ConfigurationImpl(
+      // @ts-ignore dataSystem is @internal
+      { dataSystem: { initialConnectionMode: 'polling' } },
+      {
+        getImplementationHooks: () => [],
+        credentialType: 'mobileKey',
+        dataSystemDefaults: {
+          initialConnectionMode: 'streaming',
+          backgroundConnectionMode: 'background',
+          automaticModeSwitching: true,
+        },
+      },
+    );
+    expect(config.dataSystem).toBeDefined();
+    expect(config.dataSystem!.initialConnectionMode).toBe('polling');
+    expect(config.dataSystem!.backgroundConnectionMode).toBe('background');
+    expect(config.dataSystem!.automaticModeSwitching).toBe(true);
+  });
+
+  it('warns and falls back to default for invalid dataSystem sub-fields', () => {
+    console.error = jest.fn();
+    const config = new ConfigurationImpl(
+      // @ts-ignore dataSystem is @internal
+      { dataSystem: { initialConnectionMode: 'turbo' } },
+      {
+        getImplementationHooks: () => [],
+        credentialType: 'clientSideId',
+        dataSystemDefaults: {
+          initialConnectionMode: 'one-shot',
+          automaticModeSwitching: false,
+        },
+      },
+    );
+    expect(config.dataSystem).toBeDefined();
+    expect(config.dataSystem!.initialConnectionMode).toBe('one-shot');
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('dataSystem.initialConnectionMode'),
+    );
+  });
+
+  it('does not deep-validate dataSystem when dataSystemDefaults is not provided', () => {
+    const config = new ConfigurationImpl(
+      // @ts-ignore dataSystem is @internal
+      { dataSystem: { initialConnectionMode: 'polling' } },
+      {
+        getImplementationHooks: () => [],
+        credentialType: 'clientSideId',
+      },
+    );
+    // Without defaults, deep validation is skipped — raw object from basic validator
+    expect(config.dataSystem).toBeDefined();
+  });
+});

packages/shared/sdk-client/src/configuration/Configuration.ts

@@ -10,8 +10,12 @@ import {
 } from '@launchdarkly/js-sdk-common';
 
 import { Hook, type LDOptions } from '../api';
-import type { LDClientDataSystemOptions } from '../api/datasource/LDClientDataSystemOptions';
+import type {
+  LDClientDataSystemOptions,
+  PlatformDataSystemDefaults,
+} from '../api/datasource/LDClientDataSystemOptions';
 import { LDInspection } from '../api/LDInspection';
+import { dataSystemValidators } from '../datasource/LDClientDataSystemOptions';
 import validateOptions from './validateOptions';
 import validators from './validators';
 
@@ -22,6 +26,7 @@ export interface LDClientInternalOptions extends internal.LDInternalOptions {
   getImplementationHooks: (environmentMetadata: LDPluginEnvironmentMetadata) => Hook[];
   credentialType: 'clientSideId' | 'mobileKey';
   getLegacyStorageKeys?: () => string[];
+  dataSystemDefaults?: PlatformDataSystemDefaults;
 }
 
 export interface Configuration {
@@ -182,5 +187,16 @@ export default class ConfigurationImpl implements Configuration {
 
     this.credentialType = internalOptions.credentialType;
     this.getImplementationHooks = internalOptions.getImplementationHooks;
+
+    // Deep-validate dataSystem if present, using platform-specific defaults.
+    if (pristineOptions.dataSystem !== undefined && internalOptions.dataSystemDefaults) {
+      this.dataSystem = validateOptions(
+        pristineOptions.dataSystem,
+        dataSystemValidators,
+        internalOptions.dataSystemDefaults as unknown as Record<string, unknown>,
+        this.logger,
+        'dataSystem',
+      ) as unknown as LDClientDataSystemOptions;
+    }
   }
 }