chore: Adds LDDataSystemOptions for configuring the Data System.

Author: tanderson-ld

packages/shared/common/__tests__/subsystem/DataSystem/CompositeDataSource.test.ts

@@ -7,21 +7,17 @@ import {
   DataSourceState,
   DataSystemInitializer,
   DataSystemSynchronizer,
-  InitializerFactory,
-  SynchronizerFactory,
+  LDInitializerFactory,
+  LDSynchronizerFactory,
 } from '../../../src/api/subsystem/DataSystem/DataSource';
 import { Backoff } from '../../../src/datasource/Backoff';
 
-function makeInitializerFactory(internal: DataSystemInitializer): InitializerFactory {
-  return {
-    create: () => internal,
-  };
+function makeInitializerFactory(internal: DataSystemInitializer): LDInitializerFactory {
+  return () => internal;
 }
 
-function makeSynchronizerFactory(internal: DataSystemSynchronizer): SynchronizerFactory {
-  return {
-    create: () => internal,
-  };
+function makeSynchronizerFactory(internal: DataSystemSynchronizer): LDSynchronizerFactory {
+  return () => internal;
 }
 
 function makeTestTransitionConditions(): TransitionConditions {
@@ -58,7 +54,7 @@ function makeZeroBackoff(): Backoff {
 
 it('handles initializer getting basis, switching to syncrhonizer', async () => {
   const mockInitializer1 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -73,7 +69,7 @@ it('handles initializer getting basis, switching to syncrhonizer', async () => {
 
   const mockSynchronizer1Data = { key: 'sync1' };
   const mockSynchronizer1 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -101,19 +97,19 @@ it('handles initializer getting basis, switching to syncrhonizer', async () => {
       }
     });
 
-    underTest.run(callback, jest.fn());
+    underTest.start(callback, jest.fn());
   });
 
-  expect(mockInitializer1.run).toHaveBeenCalledTimes(1);
-  expect(mockSynchronizer1.run).toHaveBeenCalledTimes(1);
+  expect(mockInitializer1.start).toHaveBeenCalledTimes(1);
+  expect(mockSynchronizer1.start).toHaveBeenCalledTimes(1);
   expect(callback).toHaveBeenCalledTimes(2);
   expect(callback).toHaveBeenNthCalledWith(1, true, { key: 'init1' });
   expect(callback).toHaveBeenNthCalledWith(2, false, { key: 'sync1' });
 });
 
 it('handles initializer getting basis, switches to synchronizer 1, falls back to synchronizer 2, recovers to synchronizer 1', async () => {
   const mockInitializer1: DataSystemInitializer = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -129,7 +125,7 @@ it('handles initializer getting basis, switches to synchronizer 1, falls back to
   let sync1RunCount = 0;
   const mockSynchronizer1Data = { key: 'sync1' };
   const mockSynchronizer1 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -142,7 +138,7 @@ it('handles initializer getting basis, switches to synchronizer 1, falls back to
               message: 'I am error...man!',
             }); // error that will lead to fallback
           } else {
-            _dataCallback(false, mockSynchronizer1Data); // second run will lead to data
+            _dataCallback(false, mockSynchronizer1Data); // second start will lead to data
           }
           sync1RunCount += 1;
         },
@@ -152,7 +148,7 @@ it('handles initializer getting basis, switches to synchronizer 1, falls back to
 
   const mockSynchronizer2Data = { key: 'sync2' };
   const mockSynchronizer2 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -181,12 +177,12 @@ it('handles initializer getting basis, switches to synchronizer 1, falls back to
       }
     });
 
-    underTest.run(callback, jest.fn());
+    underTest.start(callback, jest.fn());
   });
 
-  expect(mockInitializer1.run).toHaveBeenCalledTimes(1);
-  expect(mockSynchronizer1.run).toHaveBeenCalledTimes(2);
-  expect(mockSynchronizer2.run).toHaveBeenCalledTimes(1);
+  expect(mockInitializer1.start).toHaveBeenCalledTimes(1);
+  expect(mockSynchronizer1.start).toHaveBeenCalledTimes(2);
+  expect(mockSynchronizer2.start).toHaveBeenCalledTimes(1);
   expect(callback).toHaveBeenCalledTimes(3);
   expect(callback).toHaveBeenNthCalledWith(1, true, { key: 'init1' });
   expect(callback).toHaveBeenNthCalledWith(2, false, { key: 'sync2' }); // sync1 errors and fallsback
@@ -199,7 +195,7 @@ it('reports error when all initializers fail', async () => {
     message: 'I am initializer1 error!',
   };
   const mockInitializer1: DataSystemInitializer = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -217,7 +213,7 @@ it('reports error when all initializers fail', async () => {
     message: 'I am initializer2 error!',
   };
   const mockInitializer2: DataSystemInitializer = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -246,11 +242,11 @@ it('reports error when all initializers fail', async () => {
       }
     });
 
-    underTest.run(dataCallback, statusCallback);
+    underTest.start(dataCallback, statusCallback);
   });
 
-  expect(mockInitializer1.run).toHaveBeenCalledTimes(1);
-  expect(mockInitializer2.run).toHaveBeenCalledTimes(1);
+  expect(mockInitializer1.start).toHaveBeenCalledTimes(1);
+  expect(mockInitializer2.start).toHaveBeenCalledTimes(1);
   expect(dataCallback).toHaveBeenCalledTimes(0);
   expect(statusCallback).toHaveBeenNthCalledWith(
     1,
@@ -272,7 +268,7 @@ it('reports error when all initializers fail', async () => {
 
 it('can be stopped when in thrashing synchronizer fallback loop', async () => {
   const mockInitializer1 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -287,7 +283,7 @@ it('can be stopped when in thrashing synchronizer fallback loop', async () => {
 
   const mockSynchronizer1Error = { name: 'Error', message: 'I am error...man!' };
   const mockSynchronizer1 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -316,11 +312,11 @@ it('can be stopped when in thrashing synchronizer fallback loop', async () => {
       }
     });
 
-    underTest.run(dataCallback, statusCallback);
+    underTest.start(dataCallback, statusCallback);
   });
 
-  expect(mockInitializer1.run).toHaveBeenCalled();
-  expect(mockSynchronizer1.run).toHaveBeenCalled();
+  expect(mockInitializer1.start).toHaveBeenCalled();
+  expect(mockSynchronizer1.start).toHaveBeenCalled();
   expect(dataCallback).toHaveBeenNthCalledWith(1, true, { key: 'init1' });
   underTest.stop();
 
@@ -340,7 +336,7 @@ it('can be stopped when in thrashing synchronizer fallback loop', async () => {
 it('can be stopped and restarted', async () => {
   const mockInitializer1Data = { key: 'init1' };
   const mockInitializer1 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -355,7 +351,7 @@ it('can be stopped and restarted', async () => {
 
   const mockSynchronizer1Data = { key: 'sync1' };
   const mockSynchronizer1 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -383,13 +379,13 @@ it('can be stopped and restarted', async () => {
         resolve();
       }
     });
-    // first run
-    underTest.run(callback1, jest.fn());
+    // first start
+    underTest.start(callback1, jest.fn());
   });
 
-  // check first run triggered underlying data sources
-  expect(mockInitializer1.run).toHaveBeenCalledTimes(1);
-  expect(mockSynchronizer1.run).toHaveBeenCalledTimes(1);
+  // check first start triggered underlying data sources
+  expect(mockInitializer1.start).toHaveBeenCalledTimes(1);
+  expect(mockSynchronizer1.start).toHaveBeenCalledTimes(1);
   expect(callback1).toHaveBeenCalledTimes(2);
 
   // wait a moment for pending awaits to resolve the stop request
@@ -404,13 +400,13 @@ it('can be stopped and restarted', async () => {
         resolve();
       }
     });
-    // second run
-    underTest.run(callback2, jest.fn());
+    // second start
+    underTest.start(callback2, jest.fn());
   });
 
-  // check that second run triggers underlying data sources again
-  expect(mockInitializer1.run).toHaveBeenCalledTimes(2);
-  expect(mockSynchronizer1.run).toHaveBeenCalledTimes(2);
+  // check that second start triggers underlying data sources again
+  expect(mockInitializer1.start).toHaveBeenCalledTimes(2);
+  expect(mockSynchronizer1.start).toHaveBeenCalledTimes(2);
   expect(callback2).toHaveBeenCalledTimes(2);
 });
 
@@ -428,7 +424,7 @@ it('is well behaved with no initializers and no synchronizers configured', async
       resolve();
     });
 
-    underTest.run(jest.fn(), statusCallback);
+    underTest.start(jest.fn(), statusCallback);
   });
 
   expect(statusCallback).toHaveBeenNthCalledWith(1, DataSourceState.Closed, {
@@ -440,7 +436,7 @@ it('is well behaved with no initializers and no synchronizers configured', async
 
 it('is well behaved with an initializer and no synchronizers configured', async () => {
   const mockInitializer1 = {
-    run: jest
+    start: jest
       .fn()
       .mockImplementation(
         (
@@ -466,7 +462,7 @@ it('is well behaved with an initializer and no synchronizers configured', async
       resolve();
     });
 
-    underTest.run(jest.fn(), statusCallback);
+    underTest.start(jest.fn(), statusCallback);
   });
 
   expect(statusCallback).toHaveBeenNthCalledWith(1, DataSourceState.Closed, {

packages/shared/common/src/api/subsystem/DataSystem/CompositeDataSource.ts

@@ -6,8 +6,8 @@ import {
   Data,
   DataSource,
   DataSourceState,
-  InitializerFactory,
-  SynchronizerFactory,
+  LDInitializerFactory,
+  LDSynchronizerFactory,
 } from './DataSource';
 
 // TODO: SDK-858, specify these constants when CompositeDataSource is used.
@@ -33,6 +33,7 @@ interface TransitionRequest {
   err?: Error;
 }
 
+// TODO SDK-858: move this out of API directory to neighbor datasource folder
 /**
  * The {@link CompositeDataSource} can combine a number of {@link DataSystemInitializer}s and {@link DataSystemSynchronizer}s
  * into a single {@link DataSource}, implementing fallback and recovery logic internally to choose where data is sourced from.
@@ -54,8 +55,8 @@ export class CompositeDataSource implements DataSource {
    * @param _synchronizers factories to create  {@link DataSystemSynchronizer}s, in priority order.
    */
   constructor(
-    private readonly _initializers: InitializerFactory[],
-    private readonly _synchronizers: SynchronizerFactory[],
+    private readonly _initializers: LDInitializerFactory[],
+    private readonly _synchronizers: LDSynchronizerFactory[],
     private readonly _transitionConditions: TransitionConditions,
     private readonly _backoff: Backoff,
     private readonly _logger?: LDLogger,
@@ -67,7 +68,7 @@ export class CompositeDataSource implements DataSource {
     this._currentPosition = 0;
   }
 
-  async run(
+  async start(
     dataCallback: (basis: boolean, data: Data) => void,
     statusCallback: (status: DataSourceState, err?: any) => void,
   ): Promise<void> {
@@ -133,7 +134,7 @@ export class CompositeDataSource implements DataSource {
               }
             },
           );
-          currentDS.run(
+          currentDS.start(
             (basis, data) => callbackHandler.dataHandler(basis, data),
             (status, err) => callbackHandler.statusHandler(status, err),
           );
@@ -229,7 +230,7 @@ export class CompositeDataSource implements DataSource {
         return undefined;
       }
 
-      return this._initializers[this._currentPosition].create();
+      return this._initializers[this._currentPosition]();
     }
     // getting here indicates we are using a synchronizer
 
@@ -242,7 +243,7 @@ export class CompositeDataSource implements DataSource {
       // this is only possible if no synchronizers were provided
       return undefined;
     }
-    return this._synchronizers[this._currentPosition].create();
+    return this._synchronizers[this._currentPosition]();
   }
 
   /**

packages/shared/common/src/api/subsystem/DataSystem/DataSource.ts

@@ -15,7 +15,7 @@ export interface DataSource {
    * @param statusCallback that will be called when data source state changes or an unrecoverable error
    * has been encountered.
    */
-  run(
+  start(
     dataCallback: (basis: boolean, data: Data) => void,
     statusCallback: (status: DataSourceState, err?: any) => void,
   ): void;
@@ -26,6 +26,11 @@ export interface DataSource {
   stop(): void;
 }
 
+export type LDInitializerFactory = () => DataSystemInitializer;
+
+export type LDSynchronizerFactory = () => DataSystemSynchronizer;
+
+// TODO: renmae these to start with LD to help with API consumption
 /**
  * A data source that can be used to fetch the basis.
  */
@@ -35,11 +40,3 @@ export interface DataSystemInitializer extends DataSource {}
  * A data source that can be used to fetch the basis or ongoing data changes.
  */
 export interface DataSystemSynchronizer extends DataSource {}
-
-export interface InitializerFactory {
-  create(): DataSystemInitializer;
-}
-
-export interface SynchronizerFactory {
-  create(): DataSystemSynchronizer;
-}

packages/shared/common/src/api/subsystem/DataSystem/index.ts

@@ -1,7 +1,7 @@
 export {
   DataSystemInitializer,
   DataSystemSynchronizer,
-  InitializerFactory,
-  SynchronizerFactory,
+  LDInitializerFactory as InitializerFactory,
+  LDSynchronizerFactory as SynchronizerFactory,
 } from './DataSource';
 export { CompositeDataSource } from './CompositeDataSource';

packages/shared/common/src/api/subsystem/index.ts

@@ -1,9 +1,19 @@
+import {
+  DataSystemInitializer,
+  DataSystemSynchronizer,
+  InitializerFactory,
+  SynchronizerFactory,
+} from './DataSystem';
 import LDContextDeduplicator from './LDContextDeduplicator';
 import LDEventProcessor from './LDEventProcessor';
 import LDEventSender, { LDDeliveryStatus, LDEventSenderResult, LDEventType } from './LDEventSender';
 import { LDStreamProcessor } from './LDStreamProcessor';
 
 export {
+  DataSystemInitializer,
+  DataSystemSynchronizer,
+  InitializerFactory,
+  SynchronizerFactory,
   LDEventProcessor,
   LDContextDeduplicator,
   LDEventSender,