Add State Provider Framework (#6640)

* Add StateDefinition

Add a class for encapsulation information about state
this will often be for a domain but creations of this will
exist outside of a specific domain, hence just the name State.

* Add KeyDefinition

This adds a type that extends state definition into another sub-key
and forces creators to define the data that will be stored and how
to read the data that they expect to be stored.

* Add key-builders helper functions

Adds to function to help building keys for both keys scoped
to a specific user and for keys scoped to global storage.

Co-authored-by: Matt Gibson <MGibson1@users.noreply.github.com>

* Add updates$ stream to existing storageServices

Original commit by Matt: 823d9546fe
Co-authored-by: Matt Gibson <MGibson1@users.noreply.github.com>

* Add fromChromeEvent helper

Create a helper that creats an Observable from a chrome event
and removes the listener when the subscription is completed.

* Implement `updates$` property for chrome storage

Use fromChromeEvent to create an observable from chrome
event and map that into our expected shape.

* Add GlobalState Abstractions

* Add UserState Abstractions

* Add Default Implementations of User/Global state

Co-authored-by: Matt Gibson <MGibson1@users.noreply.github.com>

* Add Barrel File for state

Co-authored-by: Matt Gibson <MGibson1@users.noreply.github.com>

* Fix ChromeStorageServices

* Rework fromChromeEvent

Rework fromChromeEvent so we have to lie to TS less and
remove unneeded generics. I did this by caring less about
the function and more about the parameters only.

Co-authored-by: Matt Gibson <MGibson1@users.noreply.github.com>

* Fix UserStateProvider Test

* Add Inner Mock & Assert Calls

* Update Tests to use new keys

Use different key format

* Prefer returns over mutations in update

* Update Tests

* Address PR Feedback

* Be stricter with userId parameter

* Add Better Way To Determine if it was a remove

* Fix Web & Browser Storage Services

* Fix Desktop & CLI Storage Services

* Fix Test Storage Service

* Use createKey Helper

* Prefer implement to extending

* Determine storage location in providers

* Export default providers publicly

* Fix user state tests

* Name tests

* Fix CLI

* Prefer Implement In Chrome Storage

* Remove Secure Storage Option

Also throw an exception for subscribes to the secure storage observable.

* Update apps/browser/src/platform/browser/from-chrome-event.ts

Co-authored-by: Oscar Hinton <Hinton@users.noreply.github.com>

* Enforce state module barrel file

* Fix Linting Error

* Allow state module import from other modules

* Globally Unregister fromChromeEvent Listeners

Changed fromChromeEvent to add its listeners through the BrowserApi, so that
they will be unregistered when safari closes.

* Test default global state

* Use Proper Casing in Parameter

* Address Feedback

* Update libs/common/src/platform/state/key-definition.ts

Co-authored-by: Oscar Hinton <Hinton@users.noreply.github.com>

* Add `buildCacheKey` Method

* Fix lint errors

* Add Comment

Co-authored-by: Oscar Hinton <Hinton@users.noreply.github.com>

* Use Generic in callback parameter

* Refactor Out DerivedStateDefinition

* Persist Listener Return Type

* Add Ticket Link

---------

Co-authored-by: Matt Gibson <MGibson1@users.noreply.github.com>
Co-authored-by: Matt Gibson <mgibson@bitwarden.com>
Co-authored-by: Oscar Hinton <Hinton@users.noreply.github.com>

libs/common/src/platform/state/implementations/default-global-state.spec.ts

@@ -0,0 +1,98 @@
+/**
+ * need to update test environment so trackEmissions works appropriately
+ * @jest-environment ../shared/test.environment.ts
+ */
+
+import { Jsonify } from "type-fest";
+
+import { trackEmissions } from "../../../../spec";
+import { FakeStorageService } from "../../../../spec/fake-storage.service";
+import { KeyDefinition, globalKeyBuilder } from "../key-definition";
+import { StateDefinition } from "../state-definition";
+
+import { DefaultGlobalState } from "./default-global-state";
+
+class TestState {
+  date: Date;
+
+  static fromJSON(jsonState: Jsonify<TestState>) {
+    if (jsonState == null) {
+      return null;
+    }
+
+    return Object.assign(new TestState(), jsonState, {
+      date: new Date(jsonState.date),
+    });
+  }
+}
+
+const testStateDefinition = new StateDefinition("fake", "disk");
+
+const testKeyDefinition = new KeyDefinition<TestState>(
+  testStateDefinition,
+  "fake",
+  TestState.fromJSON
+);
+const globalKey = globalKeyBuilder(testKeyDefinition);
+
+describe("DefaultGlobalState", () => {
+  let diskStorageService: FakeStorageService;
+  let globalState: DefaultGlobalState<TestState>;
+
+  beforeEach(() => {
+    diskStorageService = new FakeStorageService();
+    globalState = new DefaultGlobalState(testKeyDefinition, diskStorageService);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("should emit when storage updates", async () => {
+    const emissions = trackEmissions(globalState.state$);
+    const newData = { date: new Date() };
+    await diskStorageService.save(globalKey, newData);
+
+    expect(emissions).toEqual([
+      null, // Initial value
+      newData,
+      // JSON.parse(JSON.stringify(newData)), // This is due to the way `trackEmissions` clones
+    ]);
+  });
+
+  it("should not emit when update key does not match", async () => {
+    const emissions = trackEmissions(globalState.state$);
+    const newData = { date: new Date() };
+    await diskStorageService.save("wrong_key", newData);
+
+    expect(emissions).toEqual(
+      expect.arrayContaining([
+        null, // Initial value
+      ])
+    );
+  });
+
+  it("should save on update", async () => {
+    const newData = { date: new Date() };
+    const result = await globalState.update((state) => {
+      return newData;
+    });
+
+    expect(diskStorageService.mock.save).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(newData);
+  });
+
+  it("should emit once per update", async () => {
+    const emissions = trackEmissions(globalState.state$);
+    const newData = { date: new Date() };
+
+    await globalState.update((state) => {
+      return newData;
+    });
+
+    expect(emissions).toEqual([
+      null, // Initial value
+      newData,
+    ]);
+  });
+});