refactor: shared config builder

Author: joker23

packages/sdk/browser/contract-tests/entity/src/ClientEntity.ts

@@ -8,14 +8,12 @@ import {
 } from '@launchdarkly/js-client-sdk';
 import {
   ClientEntity,
+  ConfigBuilder,
   CreateInstanceParams,
   IClientEntity,
-  makeSdkConfig,
-  parseClientOptions,
   SDKConfigDataInitializer,
   SDKConfigDataSynchronizer,
   SDKConfigModeDefinition,
-  SDKConfigParams,
 } from '@launchdarkly/js-contract-test-utils/client';
 
 function translateInitializer(init: SDKConfigDataInitializer): InitializerEntry | undefined {
@@ -71,25 +69,28 @@ function translateModeDefinition(modeDef: SDKConfigModeDefinition): ModeDefiniti
   return { initializers, synchronizers };
 }
 
-/**
- * Browser-specific makeSdkConfig that wraps the shared base config with
- * FDv2 data system translation and browser-specific options.
- */
-function makeBrowserSdkConfig(options: SDKConfigParams, tag: string): LDOptions {
-  const isSet = (x?: unknown) => x !== null && x !== undefined;
-  const maybeTime = (seconds?: number) => (isSet(seconds) ? seconds! / 1000 : undefined);
+export async function newSdkClientEntity(
+  _id: string,
+  options: CreateInstanceParams,
+): Promise<IClientEntity> {
+  const config = new ConfigBuilder(options).set({ fetchGoals: false });
 
-  const cf = { ...makeSdkConfig(options, tag), fetchGoals: false } as LDOptions;
+  if (options.configuration.dataSystem) {
+    // FDv2: skip legacy streaming — data system handles connection modes
+    config.skip('streaming');
 
-  if (options.dataSystem?.payloadFilter) {
-    cf.payloadFilterKey = options.dataSystem.payloadFilter;
-  }
+    const isSet = (x?: unknown) => x !== null && x !== undefined;
+    const maybeTime = (seconds?: number) => (isSet(seconds) ? seconds! / 1000 : undefined);
+    const fdv2Overrides: Record<string, unknown> = {};
+
+    if (options.configuration.dataSystem.payloadFilter) {
+      fdv2Overrides.payloadFilterKey = options.configuration.dataSystem.payloadFilter;
+    }
 
-  if (options.dataSystem) {
     const dataSystem: any = {};
 
-    if (options.dataSystem.connectionModeConfig) {
-      const connMode = options.dataSystem.connectionModeConfig;
+    if (options.configuration.dataSystem.connectionModeConfig) {
+      const connMode = options.configuration.dataSystem.connectionModeConfig;
       dataSystem.automaticModeSwitching = connMode.initialConnectionMode
         ? { type: 'manual', initialConnectionMode: connMode.initialConnectionMode }
         : false;
@@ -99,58 +100,49 @@ function makeBrowserSdkConfig(options: SDKConfigParams, tag: string): LDOptions
         Object.entries(connMode.customConnectionModes).forEach(([modeName, modeDef]) => {
           connectionModes[modeName] = translateModeDefinition(modeDef);
 
-          // Per-entry endpoint overrides also set global URIs for ServiceEndpoints
-          // compatibility. These override the serviceEndpoints values above.
           (modeDef.synchronizers ?? []).forEach((sync) => {
             if (sync.streaming?.baseUri) {
-              cf.streamUri = sync.streaming.baseUri;
-              cf.streamInitialReconnectDelay = maybeTime(sync.streaming.initialRetryDelayMs);
+              fdv2Overrides.streamUri = sync.streaming.baseUri;
+              fdv2Overrides.streamInitialReconnectDelay = maybeTime(
+                sync.streaming.initialRetryDelayMs,
+              );
             }
             if (sync.polling?.baseUri) {
-              cf.baseUri = sync.polling.baseUri;
+              fdv2Overrides.baseUri = sync.polling.baseUri;
             }
           });
           (modeDef.initializers ?? []).forEach((init) => {
             if (init.polling?.baseUri) {
-              cf.baseUri = init.polling.baseUri;
+              fdv2Overrides.baseUri = init.polling.baseUri;
             }
           });
         });
         dataSystem.connectionModes = connectionModes;
       }
     }
 
-    (cf as any).dataSystem = dataSystem;
+    fdv2Overrides.dataSystem = dataSystem;
+    config.set(fdv2Overrides);
   }
 
-  return cf;
-}
-
-export async function newSdkClientEntity(
-  _id: string,
-  options: CreateInstanceParams,
-): Promise<IClientEntity> {
-  const { timeout, initialContext, credential, initCanFail } = parseClientOptions(options);
-
-  const sdkConfig = makeBrowserSdkConfig(options.configuration, options.tag);
-
-  const client = createClient(credential, initialContext as LDContext, sdkConfig);
+  const sdkConfig = config.build() as LDOptions;
+  const client = createClient(config.credential, config.initialContext as LDContext, sdkConfig);
 
   let failed = false;
   try {
     await Promise.race([
       client.start(),
       new Promise((_resolve, reject) => {
-        setTimeout(reject, timeout);
+        setTimeout(reject, config.timeout);
       }),
     ]);
   } catch (_) {
     failed = true;
   }
-  if (failed && !initCanFail) {
+  if (failed && !config.initCanFail) {
     client.close();
     throw new Error('client initialization failed');
   }
 
-  return new ClientEntity(client, options.tag);
+  return new ClientEntity(client, config.tag);
 }

packages/sdk/react-native/contract-tests/entity/src/ClientEntity.ts

@@ -1,8 +1,8 @@
 import {
   ClientEntity,
+  ConfigBuilder,
   CreateInstanceParams,
   IClientEntity,
-  parseClientOptions,
 } from '@launchdarkly/js-contract-test-utils/client';
 import {
   AutoEnvAttributes,
@@ -15,24 +15,12 @@ export async function newSdkClientEntity(
   _id: string,
   options: CreateInstanceParams,
 ): Promise<IClientEntity> {
-  const { timeout, sdkConfig, initialContext, initCanFail } = parseClientOptions(options);
-
-  // Add RN-specific options
-  const rnConfig: LDOptions = {
-    ...sdkConfig,
+  const config = new ConfigBuilder(options).skip('streaming').set({
     automaticNetworkHandling: false,
     automaticBackgroundHandling: false,
-  } as LDOptions;
-
-  // RN uses initialConnectionMode instead of streaming boolean
-  if (options.configuration.polling) {
-    rnConfig.initialConnectionMode = 'polling';
-  }
-  if (options.configuration.streaming) {
-    rnConfig.initialConnectionMode = 'streaming';
-  }
-  // Remove the browser-style streaming field — RN doesn't use it
-  delete (rnConfig as Record<string, unknown>).streaming;
+    ...(options.configuration.polling && { initialConnectionMode: 'polling' }),
+    ...(options.configuration.streaming && { initialConnectionMode: 'streaming' }),
+  });
 
   const autoEnvAttributes = options.configuration.clientSide?.includeEnvironmentAttributes
     ? AutoEnvAttributes.Enabled
@@ -41,27 +29,27 @@ export async function newSdkClientEntity(
   const client = new ReactNativeLDClient(
     options.configuration.credential || 'unknown-mobile-key',
     autoEnvAttributes,
-    rnConfig,
+    config.build() as LDOptions,
   );
 
   let failed = false;
   try {
     await Promise.race([
-      client.identify(initialContext as LDContext, {
-        timeout: timeout / 1000,
+      client.identify(config.initialContext as LDContext, {
+        timeout: config.timeout / 1000,
         waitForNetworkResults: true,
       }),
       new Promise((_resolve, reject) => {
-        setTimeout(reject, timeout);
+        setTimeout(reject, config.timeout);
       }),
     ]);
   } catch (_) {
     failed = true;
   }
-  if (failed && !initCanFail) {
+  if (failed && !config.initCanFail) {
     client.close();
     throw new Error('client initialization failed');
   }
 
-  return new ClientEntity(client, options.tag);
+  return new ClientEntity(client, config.tag);
 }

packages/sdk/react/contract-tests/app/ClientRoot.tsx

@@ -4,8 +4,8 @@ import React, { useEffect, useRef, useState } from 'react';
 
 import {
   Capability,
+  ConfigBuilder,
   IClientEntity,
-  parseClientOptions,
   TestHarnessWebSocketBuilder,
 } from '@launchdarkly/js-contract-test-utils/client';
 import {
@@ -42,7 +42,6 @@ export default function ClientRoot({ children }: { children: React.ReactNode })
   const commandHandlers = useRef(new Map<string, CommandHandler>());
   const handlerReadyMap = useRef(new Map<string, () => void>());
   const clientsRef = useRef<ClientRecord[]>([]);
-  // Entity map for the WS builder's get/delete callbacks
   const entityMap = useRef(new Map<string, IClientEntity>());
 
   const onReady = (readyId: string) => {
@@ -53,18 +52,17 @@ export default function ClientRoot({ children }: { children: React.ReactNode })
     const ws = new TestHarnessWebSocketBuilder()
       .setCapabilities(CAPABILITIES)
       .onCreateClient(async (id, params) => {
-        const { timeout, sdkConfig, initialContext, credential, initCanFail } =
-          parseClientOptions(params);
+        const config = new ConfigBuilder(params).set({ fetchGoals: false });
 
         const client = createClient(
-          credential,
-          initialContext as LDContext,
-          { ...sdkConfig, fetchGoals: false } as LDOptions,
+          config.credential,
+          config.initialContext as LDContext,
+          config.build() as LDOptions,
         );
 
-        const { status } = await client.start({ timeout: timeout / 1000 });
+        const { status } = await client.start({ timeout: config.timeout / 1000 });
 
-        if (status === 'failed' && !initCanFail) {
+        if (status === 'failed' && !config.initCanFail) {
           client.close();
           throw new Error('client initialization failed');
         }