PS-813 Add memory storage to state service (#2892)

* Use abstract methods and generics in StorageService

* Prepend `Abstract` to abstract classes

* Create session browser storage service

* Use memory storage service for state memory

* Inject memory storage service

* Maintain filename extensions to help ide formatting

* Preserve state if it's still in memory

* Use jslib's memory storage service

* linter

* Create prototypes on stored objects

* standardize package scripts

* Add type safety to `withPrototype` decorators

* webpack notify manifest version

* Fix desktop

* linter

* Fix script

* Improve prototye application

* do not change prototype if it already matches desired
* fix error with object values prototype application

* Handle null state

* Apply prototypes to browser-specific state

* Add angular language server to recommended extensions

* Improve browser state service tests

* Start testing state Service

* Fix abstract returns

* Move test setup files to not be picked up by default glob matchers

* Add key generation service

* Add low-dependency encrypt service

* Back crypto service with encrypt service.

We'll want to work items that don't require state over to encrypt service

* Add new storage service and tests

* Properly init more stored values

* Fix reload issues when state service is recovering state from session storage

Co-authored-by: Thomas Avery <Thomas-Avery@users.noreply.github.com>
Co-authored-by: Justin Baur <admin@justinbaur.com>

* Simplify encrypt service

* Do not log mac failures for local-backed session storage

* `content` changed to `main` in #2245

* Fix CLI

* Remove loggin

* PR feedback

* Merge remote-tracking branch 'origin/master' into add-memory-storage-to-state-service

* Fix desktop

* Fix decrypt method signature

* Minify if not development

* Key is required

Co-authored-by: Thomas Avery <Thomas-Avery@users.noreply.github.com>
Co-authored-by: Justin Baur <admin@justinbaur.com>

libs/common/spec/services/state.service.spec.ts

@@ -0,0 +1,82 @@
+import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
+
+import { LogService } from "@bitwarden/common/abstractions/log.service";
+import { AbstractStorageService } from "@bitwarden/common/abstractions/storage.service";
+import { StateFactory } from "@bitwarden/common/factories/stateFactory";
+import { Account } from "@bitwarden/common/models/domain/account";
+import { GlobalState } from "@bitwarden/common/models/domain/globalState";
+import { State } from "@bitwarden/common/models/domain/state";
+import { StorageOptions } from "@bitwarden/common/models/domain/storageOptions";
+import { SymmetricCryptoKey } from "@bitwarden/common/models/domain/symmetricCryptoKey";
+import { StateService } from "@bitwarden/common/services/state.service";
+import { StateMigrationService } from "@bitwarden/common/services/stateMigration.service";
+
+describe("Browser State Service backed by chrome.storage api", () => {
+  let secureStorageService: SubstituteOf<AbstractStorageService>;
+  let diskStorageService: SubstituteOf<AbstractStorageService>;
+  let memoryStorageService: SubstituteOf<AbstractStorageService>;
+  let logService: SubstituteOf<LogService>;
+  let stateMigrationService: SubstituteOf<StateMigrationService>;
+  let stateFactory: SubstituteOf<StateFactory<GlobalState, Account>>;
+  let useAccountCache: boolean;
+
+  let state: State<GlobalState, Account>;
+  const userId = "userId";
+
+  let sut: StateService;
+
+  beforeEach(() => {
+    secureStorageService = Substitute.for();
+    diskStorageService = Substitute.for();
+    memoryStorageService = Substitute.for();
+    logService = Substitute.for();
+    stateMigrationService = Substitute.for();
+    stateFactory = Substitute.for();
+    useAccountCache = true;
+
+    state = new State(new GlobalState());
+    const stateGetter = (key: string) => Promise.resolve(JSON.parse(JSON.stringify(state)));
+    memoryStorageService.get("state").mimicks(stateGetter);
+    memoryStorageService
+      .save("state", Arg.any(), Arg.any())
+      .mimicks((key: string, obj: any, options: StorageOptions) => {
+        return new Promise(() => {
+          state = obj;
+        });
+      });
+
+    sut = new StateService(
+      diskStorageService,
+      secureStorageService,
+      memoryStorageService,
+      logService,
+      stateMigrationService,
+      stateFactory,
+      useAccountCache
+    );
+  });
+
+  describe("account state getters", () => {
+    beforeEach(() => {
+      state.accounts[userId] = createAccount(userId);
+      state.activeUserId = userId;
+    });
+
+    describe("getCryptoMasterKey", () => {
+      it("should return the stored SymmetricCryptoKey", async () => {
+        const key = new SymmetricCryptoKey(new Uint8Array(32).buffer);
+        state.accounts[userId].keys.cryptoMasterKey = key;
+
+        const actual = await sut.getCryptoMasterKey();
+        expect(actual).toBeInstanceOf(SymmetricCryptoKey);
+        expect(actual).toMatchObject(key);
+      });
+    });
+  });
+
+  function createAccount(userId: string): Account {
+    return new Account({
+      profile: { userId: userId },
+    });
+  }
+});

libs/common/spec/services/stateMigration.service.spec.ts

@@ -1,6 +1,6 @@
 import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
 
-import { StorageService } from "@bitwarden/common/abstractions/storage.service";
+import { AbstractStorageService } from "@bitwarden/common/abstractions/storage.service";
 import { StateVersion } from "@bitwarden/common/enums/stateVersion";
 import { StateFactory } from "@bitwarden/common/factories/stateFactory";
 import { Account } from "@bitwarden/common/models/domain/account";
@@ -10,15 +10,15 @@ import { StateMigrationService } from "@bitwarden/common/services/stateMigration
 const userId = "USER_ID";
 
 describe("State Migration Service", () => {
-  let storageService: SubstituteOf<StorageService>;
-  let secureStorageService: SubstituteOf<StorageService>;
+  let storageService: SubstituteOf<AbstractStorageService>;
+  let secureStorageService: SubstituteOf<AbstractStorageService>;
   let stateFactory: SubstituteOf<StateFactory>;
 
   let stateMigrationService: StateMigrationService;
 
   beforeEach(() => {
-    storageService = Substitute.for<StorageService>();
-    secureStorageService = Substitute.for<StorageService>();
+    storageService = Substitute.for<AbstractStorageService>();
+    secureStorageService = Substitute.for<AbstractStorageService>();
     stateFactory = Substitute.for<StateFactory>();
 
     stateMigrationService = new StateMigrationService(
@@ -28,7 +28,7 @@ describe("State Migration Service", () => {
     );
   });
 
-  describe("StateVersion 3 to 4 migration", async () => {
+  describe("StateVersion 3 to 4 migration", () => {
     beforeEach(() => {
       const globalVersion3: Partial<GlobalState> = {
         stateVersion: StateVersion.Three,