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>

apps/web/src/services/htmlStorage.service.ts

@@ -1,11 +1,11 @@
 import { Injectable } from "@angular/core";
 
-import { StorageService } from "@bitwarden/common/abstractions/storage.service";
+import { AbstractStorageService } from "@bitwarden/common/abstractions/storage.service";
 import { HtmlStorageLocation } from "@bitwarden/common/enums/htmlStorageLocation";
 import { StorageOptions } from "@bitwarden/common/models/domain/storageOptions";
 
 @Injectable()
-export class HtmlStorageService implements StorageService {
+export class HtmlStorageService implements AbstractStorageService {
   get defaultOptions(): StorageOptions {
     return { htmlStorageLocation: HtmlStorageLocation.Session };
   }

apps/web/src/services/memoryStorage.service.ts

@@ -1,30 +0,0 @@
-import { StorageService } from "@bitwarden/common/abstractions/storage.service";
-
-export class MemoryStorageService implements StorageService {
-  private store = new Map<string, any>();
-
-  get<T>(key: string): Promise<T> {
-    if (this.store.has(key)) {
-      const obj = this.store.get(key);
-      return Promise.resolve(obj as T);
-    }
-    return Promise.resolve(null);
-  }
-
-  async has(key: string): Promise<boolean> {
-    return this.get(key) != null;
-  }
-
-  save(key: string, obj: any): Promise<any> {
-    if (obj == null) {
-      return this.remove(key);
-    }
-    this.store.set(key, obj);
-    return Promise.resolve();
-  }
-
-  remove(key: string): Promise<any> {
-    this.store.delete(key);
-    return Promise.resolve();
-  }
-}

apps/web/src/services/state.service.ts

@@ -37,7 +37,7 @@ export class StateService
   }
 
   async getEncryptedCiphers(options?: StorageOptions): Promise<{ [id: string]: CipherData }> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.getEncryptedCiphers(options);
   }
 
@@ -45,14 +45,14 @@ export class StateService
     value: { [id: string]: CipherData },
     options?: StorageOptions
   ): Promise<void> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.setEncryptedCiphers(value, options);
   }
 
   async getEncryptedCollections(
     options?: StorageOptions
   ): Promise<{ [id: string]: CollectionData }> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.getEncryptedCollections(options);
   }
 
@@ -60,12 +60,12 @@ export class StateService
     value: { [id: string]: CollectionData },
     options?: StorageOptions
   ): Promise<void> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.setEncryptedCollections(value, options);
   }
 
   async getEncryptedFolders(options?: StorageOptions): Promise<{ [id: string]: FolderData }> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.getEncryptedFolders(options);
   }
 
@@ -73,12 +73,12 @@ export class StateService
     value: { [id: string]: FolderData },
     options?: StorageOptions
   ): Promise<void> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.setEncryptedFolders(value, options);
   }
 
   async getEncryptedSends(options?: StorageOptions): Promise<{ [id: string]: SendData }> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.getEncryptedSends(options);
   }
 
@@ -86,17 +86,17 @@ export class StateService
     value: { [id: string]: SendData },
     options?: StorageOptions
   ): Promise<void> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.setEncryptedSends(value, options);
   }
 
   override async getLastSync(options?: StorageOptions): Promise<string> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.getLastSync(options);
   }
 
   override async setLastSync(value: string, options?: StorageOptions): Promise<void> {
-    options = this.reconcileOptions(options, this.defaultInMemoryOptions);
+    options = this.reconcileOptions(options, await this.defaultInMemoryOptions());
     return await super.setLastSync(value, options);
   }
 }