WIP

Author: kinyoklion

packages/sdk/browser/package.json

@@ -27,7 +27,7 @@
   ],
   "scripts": {
     "clean": "rimraf dist",
-    "build": "rollup -c rollup.config.js",
+    "build": "tsc --noEmit && rollup -c rollup.config.js",
     "lint": "eslint . --ext .ts,.tsx",
     "prettier": "prettier --write '**/*.@(js|ts|tsx|json|css)' --ignore-path ../../../.prettierignore",
     "test": "NODE_OPTIONS=--experimental-vm-modules npx jest --runInBand",

packages/sdk/browser/src/BrowserClient.ts

@@ -13,13 +13,13 @@ import {
   LDHeaders,
   Platform,
 } from '@launchdarkly/js-client-sdk-common';
+import { LDIdentifyOptions } from '@launchdarkly/js-client-sdk-common/dist/api/LDIdentifyOptions';
 
 import BrowserDataManager from './BrowserDataManager';
 import GoalManager from './goals/GoalManager';
 import { Goal, isClick } from './goals/Goals';
 import validateOptions, { BrowserOptions, filterToBaseOptions } from './options';
 import BrowserPlatform from './platform/BrowserPlatform';
-import { LDIdentifyOptions } from '@launchdarkly/js-client-sdk-common/dist/api/LDIdentifyOptions';
 
 /**
  * We are not supporting dynamically setting the connection mode on the LDClient.
@@ -53,7 +53,6 @@ export class BrowserClient extends LDClientImpl {
     const baseUrl = options.baseUri ?? 'https://clientsdk.launchdarkly.com';
 
     const platform = overridePlatform ?? new BrowserPlatform(logger);
-<<<<<<< HEAD
     const validatedBrowserOptions = validateOptions(options, logger);
     const { eventUrlTransformer } = validatedBrowserOptions;
     super(
@@ -111,26 +110,8 @@ export class BrowserClient extends LDClientImpl {
           ),
       },
     );
-=======
-    const ValidatedBrowserOptions = validateOptions(options, logger);
-    const { eventUrlTransformer } = ValidatedBrowserOptions;
-    super(clientSideId, autoEnvAttributes, platform, filterToBaseOptions(options), {
-      analyticsEventPath: `/events/bulk/${clientSideId}`,
-      diagnosticEventPath: `/events/diagnostic/${clientSideId}`,
-      includeAuthorizationHeader: false,
-      highTimeoutThreshold: 5,
-      userAgentHeaderName: 'x-launchdarkly-user-agent',
-      trackEventModifier: (event: internal.InputCustomEvent) =>
-        new internal.InputCustomEvent(
-          event.context,
-          event.key,
-          event.data,
-          event.metricValue,
-          event.samplingRatio,
-          eventUrlTransformer(window.location.href),
-        ),
-    });
->>>>>>> origin/rlamb/fix-browser-contract-test-build
+
+    this.setEventSendingEnabled(true, false);
 
     if (validatedBrowserOptions.fetchGoals) {
       this.goalManager = new GoalManager(
@@ -178,8 +159,8 @@ export class BrowserClient extends LDClientImpl {
     }
   }
 
-  override async identify(context: LDContext): Promise<void> {
-    await super.identify(context);
+  override async identify(context: LDContext, identifyOptions: LDIdentifyOptions): Promise<void> {
+    await super.identify(context, identifyOptions);
     this.goalManager?.startTracking();
   }
 
@@ -192,24 +173,5 @@ export class BrowserClient extends LDClientImpl {
     }
   }
 
-<<<<<<< HEAD
   // TODO: Setup event listeners.
-=======
-  override getPollingPaths(): DataSourcePaths {
-    const parentThis = this;
-    return {
-      pathGet(encoding: Encoding, _plainContextString: string): string {
-        return `/sdk/evalx/${parentThis.clientSideId}/contexts/${base64UrlEncode(_plainContextString, encoding)}`;
-      },
-      pathReport(_encoding: Encoding, _plainContextString: string): string {
-        return `/sdk/evalx/${parentThis.clientSideId}/context`;
-      },
-    };
-  }
-
-  override async identify(context: LDContext, identifyOptions?: LDIdentifyOptions): Promise<void> {
-    await super.identify(context, identifyOptions);
-    this.goalManager?.startTracking();
-  }
->>>>>>> origin/rlamb/fix-browser-contract-test-build
 }

packages/sdk/browser/src/BrowserDataManager.ts

@@ -74,14 +74,24 @@ export default class BrowserDataManager extends DefaultDataManager {
   }
 
   startDataSource() {
-    // Should always be streaming for browser SDKs for now.
-    if (this.connectionMode !== 'streaming') {
-      this.setConnectionMode('streaming');
-    } else if (this.context && !this.updateProcessor) {
+    if (this.context && !this.updateProcessor) {
       this.setupConnection(this.context);
     }
   }
 
+  private setupConnection(
+    context: Context,
+    identifyResolve?: () => void,
+    identifyReject?: (err: Error) => void,
+  ) {
+    const rawContext = Context.toLDContext(context)!;
+
+    this.updateProcessor?.close();
+    this.createStreamingProcessor(rawContext, context, identifyResolve, identifyReject);
+
+    this.updateProcessor!.start();
+  }
+
   private getRequestor(plainContextString: string): Requestor {
     const paths = this.getPollingPaths();
     const path = this.config.useReport

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

@@ -1,6 +1,15 @@
-import { Context, DefaultDataManager, LDIdentifyOptions } from '@launchdarkly/js-client-sdk-common';
+import {
+  ConnectionMode,
+  Context,
+  DefaultDataManager,
+  LDIdentifyOptions,
+} from '@launchdarkly/js-client-sdk-common';
 
 export default class MobileDataManager extends DefaultDataManager {
+  // Not implemented yet.
+  protected networkAvailable: boolean = true;
+  protected connectionMode: ConnectionMode = 'streaming';
+
   override async identify(
     identifyResolve: () => void,
     identifyReject: (err: Error) => void,
@@ -37,4 +46,62 @@ export default class MobileDataManager extends DefaultDataManager {
       this.setupConnection(context, identifyResolve, identifyReject);
     }
   }
+
+  private setupConnection(
+    context: Context,
+    identifyResolve?: () => void,
+    identifyReject?: (err: Error) => void,
+  ) {
+    const rawContext = Context.toLDContext(context)!;
+
+    this.updateProcessor?.close();
+    switch (this.connectionMode) {
+      case 'streaming':
+        this.createStreamingProcessor(rawContext, context, identifyResolve, identifyReject);
+        break;
+      case 'polling':
+        this.createPollingProcessor(rawContext, context, identifyResolve, identifyReject);
+        break;
+      default:
+        break;
+    }
+    this.updateProcessor!.start();
+  }
+
+  setNetworkAvailability(available: boolean): void {
+    this.networkAvailable = available;
+  }
+
+  async setConnectionMode(mode: ConnectionMode): Promise<void> {
+    if (this.connectionMode === mode) {
+      this.logger.debug(`setConnectionMode ignored. Mode is already '${mode}'.`);
+      return;
+    }
+
+    this.connectionMode = mode;
+    this.logger.debug(`setConnectionMode ${mode}.`);
+
+    switch (mode) {
+      case 'offline':
+        this.updateProcessor?.close();
+        break;
+      case 'polling':
+      case 'streaming':
+        if (this.context) {
+          // identify will start the update processor
+          this.setupConnection(this.context);
+        }
+
+        break;
+      default:
+        this.logger.warn(
+          `Unknown ConnectionMode: ${mode}. Only 'offline', 'streaming', and 'polling' are supported.`,
+        );
+        break;
+    }
+  }
+
+  getConnectionMode(): ConnectionMode {
+    return this.connectionMode;
+  }
 }

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

@@ -1,4 +1,4 @@
-import { LDOptions } from '@launchdarkly/js-client-sdk-common';
+import { ConnectionMode, LDOptions } from '@launchdarkly/js-client-sdk-common';
 
 /**
  * Interface for providing custom storage implementations for react Native.
@@ -95,6 +95,16 @@ export interface RNSpecificOptions {
    * Defaults to @react-native-async-storage/async-storage.
    */
   readonly storage?: RNStorage;
+
+  /**
+   * Sets the mode to use for connections when the SDK is initialized.
+   *
+   * @remarks
+   * Possible values are offline or streaming. See {@link ConnectionMode} for more information.
+   *
+   * @defaultValue streaming.
+   */
+  initialConnectionMode?: ConnectionMode;
 }
 
 export default interface RNOptions extends LDOptions, RNSpecificOptions {}

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

@@ -104,17 +104,18 @@ export default class ReactNativeLDClient extends LDClientImpl {
       internalOptions,
     );
 
+    const dataManager = this.dataManager as MobileDataManager;
     const destination: ConnectionDestination = {
       setNetworkAvailability: (available: boolean) => {
-        this.setNetworkAvailability(available);
+        dataManager.setNetworkAvailability(available);
       },
       setEventSendingEnabled: (enabled: boolean, flush: boolean) => {
         this.setEventSendingEnabled(enabled, flush);
       },
       setConnectionMode: async (mode: ConnectionMode) => {
         // Pass the connection mode to the base implementation.
         // The RN implementation will pass the connection mode through the connection manager.
-        this.baseSetConnectionMode(mode);
+        dataManager.setConnectionMode(mode);
       },
     };
 
@@ -132,16 +133,24 @@ export default class ReactNativeLDClient extends LDClientImpl {
     );
   }
 
-  private baseSetConnectionMode(mode: ConnectionMode) {
-    // Jest had problems with calls to super from nested arrow functions, so this method proxies the call.
-    super.setConnectionMode(mode);
-  }
-
-  override async setConnectionMode(mode: ConnectionMode): Promise<void> {
+  async setConnectionMode(mode: ConnectionMode): Promise<void> {
     // Set the connection mode before setting offline, in case there is any mode transition work
     // such as flushing on entering the background.
     this.connectionManager.setConnectionMode(mode);
     // For now the data source connection and the event processing state are connected.
     this.connectionManager.setOffline(mode === 'offline');
   }
+
+  /**
+   * Gets the SDK connection mode.
+   */
+  getConnectionMode(): ConnectionMode {
+    const dataManager = this.dataManager as MobileDataManager;
+    return dataManager.getConnectionMode();
+  }
+
+  isOffline() {
+    const dataManager = this.dataManager as MobileDataManager;
+    return dataManager.getConnectionMode() === 'offline';
+  }
 }

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

@@ -1,4 +1,5 @@
 import {
+  ConnectionMode,
   LDLogger,
   LDOptions,
   OptionMessages,
@@ -8,25 +9,37 @@ import {
 
 import RNOptions, { RNStorage } from './RNOptions';
 
+class ConnectionModeValidator implements TypeValidator {
+  is(u: unknown): u is ConnectionMode {
+    return u === 'offline' || u === 'streaming' || u === 'polling';
+  }
+  getType(): string {
+    return 'ConnectionMode (offline | streaming | polling)';
+  }
+}
+
 export interface ValidatedOptions {
   runInBackground: boolean;
   automaticNetworkHandling: boolean;
   automaticBackgroundHandling: boolean;
   storage?: RNStorage;
+  initialConnectionMode: ConnectionMode;
 }
 
-const optDefaults = {
+const optDefaults: ValidatedOptions = {
   runInBackground: false,
   automaticNetworkHandling: true,
   automaticBackgroundHandling: true,
   storage: undefined,
+  initialConnectionMode: 'streaming',
 };
 
 const validators: { [Property in keyof RNOptions]: TypeValidator | undefined } = {
   runInBackground: TypeValidators.Boolean,
   automaticNetworkHandling: TypeValidators.Boolean,
   automaticBackgroundHandling: TypeValidators.Boolean,
   storage: TypeValidators.Object,
+  initialConnectionMode: new ConnectionModeValidator(),
 };
 
 export function filterToBaseOptions(opts: RNOptions): LDOptions {
@@ -48,6 +61,7 @@ export default function validateOptions(opts: RNOptions, logger: LDLogger): Vali
     const value = opts[key];
     if (value !== undefined) {
       if (validator.is(value)) {
+        // @ts-ignore The type inference has some problems here.
         output[key as keyof ValidatedOptions] = value as any;
       } else {
         logger.warn(OptionMessages.wrongOptionType(key, validator.getType(), typeof value));

packages/shared/common/src/internal/events/EventProcessor.ts

@@ -130,7 +130,6 @@ export default class EventProcessor implements LDEventProcessor {
     baseHeaders: LDHeaders,
     private readonly contextDeduplicator?: LDContextDeduplicator,
     private readonly diagnosticsManager?: DiagnosticsManager,
-    start: boolean = true,
   ) {
     this.capacity = config.eventsCapacity;
     this.logger = clientContext.basicConfiguration.logger;
@@ -140,10 +139,6 @@ export default class EventProcessor implements LDEventProcessor {
       config.allAttributesPrivate,
       config.privateAttributes.map((ref) => new AttributeReference(ref)),
     );
-
-    if (start) {
-      this.start();
-    }
   }
 
   start() {