feat: adding start() method to common client sdk package

Author: joker23

packages/sdk/browser/__tests__/BrowserClient.test.ts

@@ -21,10 +21,8 @@ import {
   LDIdentifyResult,
   LDPluginEnvironmentMetadata,
   LDWaitForInitializationOptions,
-  LDWaitForInitializationResult,
   MODE_TABLE,
   Platform,
-  readFlagsFromBootstrap,
   resolveForegroundMode,
   safeRegisterDebugOverridePlugins,
 } from '@launchdarkly/js-client-sdk-common';
@@ -45,11 +43,6 @@ class BrowserClientImpl extends LDClientImpl {
   private readonly _goalManager?: GoalManager;
   private readonly _plugins?: LDPlugin[];
 
-  private _initialContext?: LDContext;
-
-  // NOTE: This also keeps track of when we tried to initialize the client.
-  private _startPromise?: Promise<LDWaitForInitializationResult>;
-
   constructor(
     clientSideId: string,
     autoEnvAttributes: AutoEnvAttributes,
@@ -156,6 +149,7 @@ class BrowserClientImpl extends LDClientImpl {
       getImplementationHooks: (environmentMetadata: LDPluginEnvironmentMetadata) =>
         internal.safeGetHooks(logger, environmentMetadata, validatedBrowserOptions.plugins),
       credentialType: 'clientSideId',
+      requiresStart: true,
     });
 
     this.setEventSendingEnabled(true, false);
@@ -234,10 +228,6 @@ class BrowserClientImpl extends LDClientImpl {
     }
   }
 
-  setInitialContext(context: LDContext): void {
-    this._initialContext = context;
-  }
-
   override async identify(context: LDContext, identifyOptions?: LDIdentifyOptions): Promise<void> {
     return super.identify(context, identifyOptions);
   }
@@ -246,79 +236,11 @@ class BrowserClientImpl extends LDClientImpl {
     context: LDContext,
     identifyOptions?: LDIdentifyOptions,
   ): Promise<LDIdentifyResult> {
-    if (!this._startPromise) {
-      this.logger.error(
-        'Client must be started before it can identify a context, did you forget to call start()?',
-      );
-      return { status: 'error', error: new Error('Identify called before start') };
-    }
-
-    const identifyOptionsWithUpdatedDefaults = {
-      ...identifyOptions,
-    };
-    if (identifyOptions?.sheddable === undefined) {
-      identifyOptionsWithUpdatedDefaults.sheddable = true;
-    }
-
-    const res = await super.identifyResult(context, identifyOptionsWithUpdatedDefaults);
-
+    const res = await super.identifyResult(context, identifyOptions);
     this._goalManager?.startTracking();
     return res;
   }
 
-  start(options?: LDStartOptions): Promise<LDWaitForInitializationResult> {
-    if (this.initializeResult) {
-      return Promise.resolve(this.initializeResult);
-    }
-    if (this._startPromise) {
-      return this._startPromise;
-    }
-    if (!this._initialContext) {
-      this.logger.error('Initial context not set');
-      return Promise.resolve({ status: 'failed', error: new Error('Initial context not set') });
-    }
-
-    // When we get to this point, we assume this is the first time that start is being
-    // attempted. This line should only be called once during the lifetime of the client.
-    const identifyOptions = {
-      ...(options?.identifyOptions ?? {}),
-
-      // Initial identify operations are not sheddable.
-      sheddable: false,
-    };
-
-    // If the bootstrap data is provided in the start options, and the identify options do not have bootstrap data,
-    // then use the bootstrap data from the start options.
-    if (options?.bootstrap && !identifyOptions.bootstrap) {
-      identifyOptions.bootstrap = options.bootstrap;
-    }
-
-    if (identifyOptions?.bootstrap) {
-      try {
-        if (!identifyOptions.bootstrapParsed) {
-          identifyOptions.bootstrapParsed = readFlagsFromBootstrap(
-            this.logger,
-            identifyOptions.bootstrap,
-          );
-        }
-        this.presetFlags(identifyOptions.bootstrapParsed!);
-      } catch (error) {
-        this.logger.error('Failed to bootstrap data', error);
-      }
-    }
-
-    if (!this.initializedPromise) {
-      this.initializedPromise = new Promise((resolve) => {
-        this.initResolve = resolve;
-      });
-    }
-
-    this._startPromise = this.promiseWithTimeout(this.initializedPromise!, options?.timeout ?? 5);
-
-    this.identifyResult(this._initialContext!, identifyOptions);
-    return this._startPromise;
-  }
-
   setConnectionMode(mode?: FDv2ConnectionMode): void {
     if (!this.dataManager.setConnectionMode) {
       this.logger.warn(

packages/sdk/browser/src/BrowserClient.ts

@@ -1,5 +1,6 @@
 import {
   LDClient as CommonClient,
+  LDStartOptions as CommonLDStartOptions,
   FDv2ConnectionMode,
   LDContext,
   LDIdentifyResult,
@@ -9,18 +10,11 @@ import {
 
 import { BrowserIdentifyOptions as LDIdentifyOptions } from './BrowserIdentifyOptions';
 
-export interface LDStartOptions extends LDWaitForInitializationOptions {
-  /**
-   * Optional bootstrap data to use for the identify operation. If {@link LDIdentifyOptions.bootstrap} is provided, it will be ignored.
-   */
-  bootstrap?: unknown;
-
-  /**
-   * Optional identify options to use for the identify operation. See {@link LDIdentifyOptions} for more information.
-   *
-   * @remarks
-   * Since the first identify option should never be sheddable, we omit the sheddable option from the interface to avoid confusion.
-   */
+/**
+ * Browser-specific start options that extend the common start options
+ * with browser-specific identify options (see {@link LDIdentifyOptions}).
+ */
+export interface LDStartOptions extends CommonLDStartOptions {
   identifyOptions?: Omit<LDIdentifyOptions, 'sheddable'>;
 }
 

packages/sdk/browser/src/LDClient.ts

@@ -766,10 +766,7 @@ it('can use bootstrap data with identify', async () => {
   expect(mockedCreateEventSource).toHaveBeenCalled();
 });
 
-it('parses bootstrap data only once when identify is called with bootstrap', async () => {
-  const commonModule = await import('@launchdarkly/js-client-sdk-common');
-  const readFlagsFromBootstrapSpy = jest.spyOn(commonModule, 'readFlagsFromBootstrap');
-
+it('parses bootstrap data when start is called with bootstrap', async () => {
   (ElectronPlatform as jest.Mock).mockReturnValue({
     crypto: new ElectronCrypto(),
     info: new ElectronInfo(),
@@ -796,7 +793,8 @@ it('parses bootstrap data only once when identify is called with bootstrap', asy
 
   await client.start({ bootstrap: goodBootstrapData });
 
-  expect(readFlagsFromBootstrapSpy).toHaveBeenCalledTimes(1);
-  expect(readFlagsFromBootstrapSpy).toHaveBeenCalledWith(expect.anything(), goodBootstrapData);
-  readFlagsFromBootstrapSpy.mockRestore();
+  // Verify that bootstrap data was parsed and flags are available.
+  expect(client.allFlags().killswitch).toBe(true);
+  expect(client.allFlags()['string-flag']).toBe('is bob');
+  expect(client.allFlags().cat).toBe(false);
 });

packages/sdk/electron/__tests__/ElectronClient.test.ts

@@ -17,12 +17,10 @@ import {
   LDFlagValue,
   LDHeaders,
   LDIdentifyOptions,
-  LDIdentifyResult,
   LDPluginEnvironmentMetadata,
   LDWaitForInitializationOptions,
   LDWaitForInitializationResult,
   mobileFdv1Endpoints,
-  readFlagsFromBootstrap,
 } from '@launchdarkly/js-client-sdk-common';
 
 import ElectronDataManager from './ElectronDataManager';
@@ -40,10 +38,6 @@ import validateOptions, { filterToBaseOptions } from './options';
 import ElectronPlatform from './platform/ElectronPlatform';
 
 export class ElectronClient extends LDClientImpl {
-  private readonly _initialContext: LDContext;
-
-  private _startPromise?: Promise<LDWaitForInitializationResult>;
-
   private readonly _plugins: LDPlugin[];
 
   private _ipcNamespace?: string;
@@ -90,6 +84,7 @@ export class ElectronClient extends LDClientImpl {
       getImplementationHooks: (_environmentMetadata: LDPluginEnvironmentMetadata) =>
         internal.safeGetHooks(logger, _environmentMetadata, validatedElectronOptions.plugins),
       credentialType: useClientSideId ? 'clientSideId' : 'mobileKey',
+      requiresStart: true,
     };
 
     const platform = new ElectronPlatform(logger, credential, options);
@@ -122,7 +117,7 @@ export class ElectronClient extends LDClientImpl {
       internalOptions,
     );
 
-    this._initialContext = initialContext;
+    this.setInitialContext(initialContext);
     this._plugins = validatedElectronOptions.plugins;
     this.setEventSendingEnabled(!this.isOffline(), false);
 
@@ -139,78 +134,6 @@ export class ElectronClient extends LDClientImpl {
     internal.safeRegisterPlugins(this.logger, this.environmentMetadata, client, this._plugins);
   }
 
-  start(options?: LDStartOptions): Promise<LDWaitForInitializationResult> {
-    if (this.initializeResult !== undefined) {
-      return Promise.resolve(this.initializeResult);
-    }
-    if (this._startPromise) {
-      return this._startPromise;
-    }
-    if (!this._initialContext) {
-      this.logger.error('Initial context not set');
-      return Promise.resolve({ status: 'failed', error: new Error('Initial context not set') });
-    }
-
-    const identifyOptions: LDIdentifyOptions = {
-      ...(options?.identifyOptions ?? {}),
-      sheddable: false,
-    };
-
-    if (
-      options?.bootstrap !== undefined &&
-      options?.bootstrap !== null &&
-      !identifyOptions.bootstrap
-    ) {
-      identifyOptions.bootstrap = options.bootstrap;
-    }
-
-    if (identifyOptions.bootstrap) {
-      try {
-        if (!identifyOptions.bootstrapParsed) {
-          identifyOptions.bootstrapParsed = readFlagsFromBootstrap(
-            this.logger,
-            identifyOptions.bootstrap,
-          );
-        }
-        this.presetFlags(identifyOptions.bootstrapParsed!);
-      } catch (error) {
-        this.logger.error('Failed to bootstrap data', error);
-      }
-    }
-
-    if (!this.initializedPromise) {
-      this.initializedPromise = new Promise((resolve) => {
-        this.initResolve = resolve;
-      });
-    }
-
-    this._startPromise = this.promiseWithTimeout(this.initializedPromise!, options?.timeout ?? 5);
-
-    this.identifyResult(this._initialContext, identifyOptions);
-    return this._startPromise;
-  }
-
-  override async identifyResult(
-    pristineContext: LDContext,
-    identifyOptions?: LDIdentifyOptions,
-  ): Promise<LDIdentifyResult> {
-    if (!this._startPromise) {
-      this.logger.error(
-        'Client must be started before it can identify a context, did you forget to call start()?',
-      );
-      return { status: 'error', error: new Error('Identify called before start') };
-    }
-
-    const identifyOptionsWithUpdatedDefaults = {
-      ...identifyOptions,
-    };
-    if (identifyOptions?.sheddable === undefined) {
-      identifyOptionsWithUpdatedDefaults.sheddable = true;
-    }
-
-    return super.identifyResult(pristineContext, identifyOptionsWithUpdatedDefaults);
-  }
-
   async setConnectionMode(mode: ConnectionMode): Promise<void> {
     if (mode === 'offline') {
       this.setEventSendingEnabled(false, true);

packages/sdk/electron/src/ElectronClient.ts

@@ -4,23 +4,11 @@ import type {
   LDContext,
   LDIdentifyOptions,
   LDIdentifyResult,
-  LDWaitForInitializationOptions,
+  LDStartOptions,
   LDWaitForInitializationResult,
 } from '@launchdarkly/js-client-sdk-common';
 
-export interface LDStartOptions extends LDWaitForInitializationOptions {
-  /**
-   * Optional bootstrap data to use for the identify operation. If
-   * {@link LDIdentifyOptions.bootstrap} is provided in identifyOptions, it takes precedence.
-   */
-  bootstrap?: unknown;
-
-  /**
-   * Optional identify options to use for the first identify. Since the first identify is not
-   * sheddable, the sheddable option is omitted from this type.
-   */
-  identifyOptions?: Omit<LDIdentifyOptions, 'sheddable'>;
-}
+export type { LDStartOptions };
 
 export interface LDClient extends Omit<LDClientBase, 'identify'> {
   /**