chore: adds DataSource interface, CompositeDataSource, and FDv2 paylo… (#830)

**Requirements**

- [x] I have added test coverage for new or changed functionality
- [x] I have followed the repository's [pull request submission
guidelines](../blob/main/CONTRIBUTING.md#submitting-pull-requests)
- [ ] I have validated my changes against all supported platform
versions
Classes are independent of platforms for the moment, and also not
reachable. (Except for Backoff which was moved).

This PR moves shared/common changes for FDv2 from the temporary holding
branch to main. All code has been previously reviewed and was picked
from the temporary holding branch using file pick commands.

Additional prettier fix commits.

---------

Co-authored-by: Todd Anderson <[email protected]>

Author: tanderson-ld

.github/workflows/common.yml

@@ -33,4 +33,4 @@ jobs:
           target_file: 'packages/shared/common/dist/esm/index.mjs'
           package_name: '@launchdarkly/js-sdk-common'
           pr_number: ${{ github.event.number }}
-          size_limit: 21000
+          size_limit: 25000

packages/sdk/browser/src/platform/DefaultBrowserEventSource.ts

@@ -1,13 +1,12 @@
 import {
+  DefaultBackoff,
   EventListener,
   EventName,
   EventSourceInitDict,
   HttpErrorResponse,
   EventSource as LDEventSource,
 } from '@launchdarkly/js-client-sdk-common';
 
-import Backoff from './Backoff';
-
 /**
  * Implementation Notes:
  *
@@ -22,7 +21,7 @@ import Backoff from './Backoff';
  */
 export default class DefaultBrowserEventSource implements LDEventSource {
   private _es?: EventSource;
-  private _backoff: Backoff;
+  private _backoff: DefaultBackoff;
   private _errorFilter: (err: HttpErrorResponse) => boolean;
 
   // The type of the handle can be platform specific and we treat is opaquely.
@@ -34,7 +33,10 @@ export default class DefaultBrowserEventSource implements LDEventSource {
     private readonly _url: string,
     options: EventSourceInitDict,
   ) {
-    this._backoff = new Backoff(options.initialRetryDelayMillis, options.retryResetIntervalMillis);
+    this._backoff = new DefaultBackoff(
+      options.initialRetryDelayMillis,
+      options.retryResetIntervalMillis,
+    );
     this._errorFilter = options.errorFilter;
     this._openConnection();
   }

packages/sdk/browser/__tests__/platform/Backoff.test.ts renamed to packages/shared/common/__tests__/datasource/Backoff.test.ts

@@ -1,29 +1,29 @@
-import Backoff from '../../src/platform/Backoff';
+import { DefaultBackoff } from '../../src/datasource/Backoff';
 
 const noJitter = (): number => 0;
 const maxJitter = (): number => 1;
 const defaultResetInterval = 60 * 1000;
 
 it.each([1, 1000, 5000])('has the correct starting delay', (initialDelay) => {
-  const backoff = new Backoff(initialDelay, defaultResetInterval, noJitter);
+  const backoff = new DefaultBackoff(initialDelay, defaultResetInterval, noJitter);
   expect(backoff.fail()).toEqual(initialDelay);
 });
 
 it.each([1, 1000, 5000])('doubles delay on consecutive failures', (initialDelay) => {
-  const backoff = new Backoff(initialDelay, defaultResetInterval, noJitter);
+  const backoff = new DefaultBackoff(initialDelay, defaultResetInterval, noJitter);
   expect(backoff.fail()).toEqual(initialDelay);
   expect(backoff.fail()).toEqual(initialDelay * 2);
   expect(backoff.fail()).toEqual(initialDelay * 4);
 });
 
 it('stops increasing delay when the max backoff is encountered', () => {
-  const backoff = new Backoff(5000, defaultResetInterval, noJitter);
+  const backoff = new DefaultBackoff(5000, defaultResetInterval, noJitter);
   expect(backoff.fail()).toEqual(5000);
   expect(backoff.fail()).toEqual(10000);
   expect(backoff.fail()).toEqual(20000);
   expect(backoff.fail()).toEqual(30000);
 
-  const backoff2 = new Backoff(1000, defaultResetInterval, noJitter);
+  const backoff2 = new DefaultBackoff(1000, defaultResetInterval, noJitter);
   expect(backoff2.fail()).toEqual(1000);
   expect(backoff2.fail()).toEqual(2000);
   expect(backoff2.fail()).toEqual(4000);
@@ -33,12 +33,12 @@ it('stops increasing delay when the max backoff is encountered', () => {
 });
 
 it('handles an initial retry delay longer than the maximum retry delay', () => {
-  const backoff = new Backoff(40000, defaultResetInterval, noJitter);
+  const backoff = new DefaultBackoff(40000, defaultResetInterval, noJitter);
   expect(backoff.fail()).toEqual(30000);
 });
 
 it('jitters the backoff value', () => {
-  const backoff = new Backoff(1000, defaultResetInterval, maxJitter);
+  const backoff = new DefaultBackoff(1000, defaultResetInterval, maxJitter);
   expect(backoff.fail()).toEqual(500);
   expect(backoff.fail()).toEqual(1000);
   expect(backoff.fail()).toEqual(2000);
@@ -51,7 +51,7 @@ it.each([10 * 1000, 60 * 1000])(
   'resets the delay when the last successful connection was connected greater than the retry reset interval',
   (retryResetInterval) => {
     let time = 1000;
-    const backoff = new Backoff(1000, retryResetInterval, noJitter);
+    const backoff = new DefaultBackoff(1000, retryResetInterval, noJitter);
     expect(backoff.fail(time)).toEqual(1000);
     time += 1;
     backoff.success(time);
@@ -69,7 +69,7 @@ it.each([10 * 1000, 60 * 1000])(
 it.each([10 * 1000, 60 * 1000])(
   'does not reset the delay when the connection did not persist longer than the retry reset interval',
   (retryResetInterval) => {
-    const backoff = new Backoff(1000, retryResetInterval, noJitter);
+    const backoff = new DefaultBackoff(1000, retryResetInterval, noJitter);
 
     let time = 1000;
     expect(backoff.fail(time)).toEqual(1000);

packages/shared/common/__tests__/datasource/dataSourceList.test.ts

@@ -0,0 +1,127 @@
+import { DataSourceList } from '../../src/datasource/dataSourceList';
+
+it('replace is well behaved', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  underTest.replace([4, 5, 6]);
+  expect(underTest.next()).toEqual(4);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(6);
+  expect(underTest.next()).toEqual(4);
+  expect(underTest.next()).toEqual(5);
+});
+
+it('it cycles correctly after replacing non-empty list', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+
+  underTest.remove(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+
+  underTest.remove(3);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(2);
+
+  underTest.remove(2);
+  expect(underTest.next()).toBeUndefined();
+  expect(underTest.next()).toBeUndefined();
+  expect(underTest.next()).toBeUndefined();
+
+  underTest.replace([4, 5, 6]);
+
+  expect(underTest.next()).toEqual(4);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(6);
+
+  underTest.remove(4);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(6);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(6);
+
+  underTest.remove(6);
+  expect(underTest.next()).toEqual(5);
+  expect(underTest.next()).toEqual(5);
+
+  underTest.remove(5);
+  expect(underTest.next()).toBeUndefined();
+  expect(underTest.next()).toBeUndefined();
+});
+
+it('cycles correctly after replacing empty list', async () => {
+  const underTest = new DataSourceList<number>(true, []);
+
+  underTest.replace([1, 2, 3]);
+
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+
+  underTest.remove(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+
+  underTest.remove(3);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(2);
+
+  underTest.remove(2);
+  expect(underTest.next()).toBeUndefined();
+  expect(underTest.next()).toBeUndefined();
+});
+
+it('removing head is well behaved at start', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  // head is now pointing to 1
+  underTest.remove(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(3);
+  expect(underTest.next()).toEqual(2);
+});
+
+it('removing head is well behaved in middle', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  expect(underTest.next()).toEqual(1);
+  // head is now pointing to 2
+  underTest.remove(2);
+  expect(underTest.next()).toEqual(3);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(3);
+});
+
+it('removing head is well behaved at end', async () => {
+  const underTest = new DataSourceList(true, [1, 2, 3]);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  // head is now pointing to 3
+  underTest.remove(3);
+  expect(underTest.next()).toEqual(1);
+  expect(underTest.next()).toEqual(2);
+  expect(underTest.next()).toEqual(1);
+});
+
+it('removing existing returns true', async () => {
+  const underTest = new DataSourceList<number>(true, [1]);
+  expect(underTest.remove(1)).toEqual(true);
+  expect(underTest.next()).toBeUndefined();
+});
+
+it('removing nonexistent returns false', async () => {
+  const underTest = new DataSourceList<number>(true, []);
+  expect(underTest.remove(1)).toEqual(false);
+  expect(underTest.next()).toBeUndefined();
+});
+
+it('single element removed and next called', async () => {
+  const underTest = new DataSourceList<number>(true, [1]);
+  expect(underTest.remove(1)).toEqual(true);
+  expect(underTest.next()).toBeUndefined();
+});