[PM-5559] Implement User Notification Settings state provider (#8032)

* create user notification settings state provider

* replace state service get/set disableAddLoginNotification and disableChangedPasswordNotification with user notification settings service equivalents

* migrate disableAddLoginNotification and disableChangedPasswordNotification global settings to user notification settings state provider

* add content script messaging the background for enableChangedPasswordPrompt setting

* Implementing feedback to provide on PR

* Implementing feedback to provide on PR

* PR suggestions cleanup

---------

Co-authored-by: Cesar Gonzalez <cgonzalez@bitwarden.com>

libs/common/src/autofill/services/user-notification-settings.service.ts

@@ -0,0 +1,60 @@
+import { map, Observable } from "rxjs";
+
+import {
+  USER_NOTIFICATION_SETTINGS_DISK,
+  GlobalState,
+  KeyDefinition,
+  StateProvider,
+} from "../../platform/state";
+
+const ENABLE_ADDED_LOGIN_PROMPT = new KeyDefinition(
+  USER_NOTIFICATION_SETTINGS_DISK,
+  "enableAddedLoginPrompt",
+  {
+    deserializer: (value: boolean) => value ?? true,
+  },
+);
+const ENABLE_CHANGED_PASSWORD_PROMPT = new KeyDefinition(
+  USER_NOTIFICATION_SETTINGS_DISK,
+  "enableChangedPasswordPrompt",
+  {
+    deserializer: (value: boolean) => value ?? true,
+  },
+);
+
+export abstract class UserNotificationSettingsServiceAbstraction {
+  enableAddedLoginPrompt$: Observable<boolean>;
+  setEnableAddedLoginPrompt: (newValue: boolean) => Promise<void>;
+  enableChangedPasswordPrompt$: Observable<boolean>;
+  setEnableChangedPasswordPrompt: (newValue: boolean) => Promise<void>;
+}
+
+export class UserNotificationSettingsService implements UserNotificationSettingsServiceAbstraction {
+  private enableAddedLoginPromptState: GlobalState<boolean>;
+  readonly enableAddedLoginPrompt$: Observable<boolean>;
+
+  private enableChangedPasswordPromptState: GlobalState<boolean>;
+  readonly enableChangedPasswordPrompt$: Observable<boolean>;
+
+  constructor(private stateProvider: StateProvider) {
+    this.enableAddedLoginPromptState = this.stateProvider.getGlobal(ENABLE_ADDED_LOGIN_PROMPT);
+    this.enableAddedLoginPrompt$ = this.enableAddedLoginPromptState.state$.pipe(
+      map((x) => x ?? true),
+    );
+
+    this.enableChangedPasswordPromptState = this.stateProvider.getGlobal(
+      ENABLE_CHANGED_PASSWORD_PROMPT,
+    );
+    this.enableChangedPasswordPrompt$ = this.enableChangedPasswordPromptState.state$.pipe(
+      map((x) => x ?? true),
+    );
+  }
+
+  async setEnableAddedLoginPrompt(newValue: boolean): Promise<void> {
+    await this.enableAddedLoginPromptState.update(() => newValue);
+  }
+
+  async setEnableChangedPasswordPrompt(newValue: boolean): Promise<void> {
+    await this.enableChangedPasswordPromptState.update(() => newValue);
+  }
+}

libs/common/src/platform/abstractions/state.service.ts

@@ -200,13 +200,6 @@ export abstract class StateService<T extends Account = Account> {
   setDecryptedSends: (value: SendView[], options?: StorageOptions) => Promise<void>;
   getDefaultUriMatch: (options?: StorageOptions) => Promise<UriMatchType>;
   setDefaultUriMatch: (value: UriMatchType, options?: StorageOptions) => Promise<void>;
-  getDisableAddLoginNotification: (options?: StorageOptions) => Promise<boolean>;
-  setDisableAddLoginNotification: (value: boolean, options?: StorageOptions) => Promise<void>;
-  getDisableChangedPasswordNotification: (options?: StorageOptions) => Promise<boolean>;
-  setDisableChangedPasswordNotification: (
-    value: boolean,
-    options?: StorageOptions,
-  ) => Promise<void>;
   getDisableContextMenuItem: (options?: StorageOptions) => Promise<boolean>;
   setDisableContextMenuItem: (value: boolean, options?: StorageOptions) => Promise<void>;
   /**

libs/common/src/platform/models/domain/global-state.ts

@@ -26,8 +26,6 @@ export class GlobalState {
   enableBrowserIntegrationFingerprint?: boolean;
   enableDuckDuckGoBrowserIntegration?: boolean;
   neverDomains?: { [id: string]: unknown };
-  disableAddLoginNotification?: boolean;
-  disableChangedPasswordNotification?: boolean;
   disableContextMenuItem?: boolean;
   deepLinkRedirectUrl?: string;
 }

libs/common/src/platform/services/state.service.ts

@@ -853,45 +853,6 @@ export class StateService<
     );
   }
 
-  async getDisableAddLoginNotification(options?: StorageOptions): Promise<boolean> {
-    return (
-      (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
-        ?.disableAddLoginNotification ?? false
-    );
-  }
-
-  async setDisableAddLoginNotification(value: boolean, options?: StorageOptions): Promise<void> {
-    const globals = await this.getGlobals(
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-    globals.disableAddLoginNotification = value;
-    await this.saveGlobals(
-      globals,
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-  }
-
-  async getDisableChangedPasswordNotification(options?: StorageOptions): Promise<boolean> {
-    return (
-      (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
-        ?.disableChangedPasswordNotification ?? false
-    );
-  }
-
-  async setDisableChangedPasswordNotification(
-    value: boolean,
-    options?: StorageOptions,
-  ): Promise<void> {
-    const globals = await this.getGlobals(
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-    globals.disableChangedPasswordNotification = value;
-    await this.saveGlobals(
-      globals,
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-  }
-
   async getDisableContextMenuItem(options?: StorageOptions): Promise<boolean> {
     return (
       (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))

libs/common/src/platform/state/state-definitions.ts

@@ -63,6 +63,10 @@ export const VAULT_FILTER_DISK = new StateDefinition("vaultFilter", "disk", {
   web: "disk-local",
 });
 
+export const USER_NOTIFICATION_SETTINGS_DISK = new StateDefinition(
+  "userNotificationSettings",
+  "disk",
+);
 export const CLEAR_EVENT_DISK = new StateDefinition("clearEvent", "disk");
 
 export const NEW_WEB_LAYOUT_BANNER_DISK = new StateDefinition("newWebLayoutBanner", "disk", {

libs/common/src/state-migrations/migrate.ts

@@ -23,6 +23,7 @@ import { ClearClipboardDelayMigrator } from "./migrations/25-move-clear-clipboar
 import { RevertLastSyncMigrator } from "./migrations/26-revert-move-last-sync-to-state-provider";
 import { BadgeSettingsMigrator } from "./migrations/27-move-badge-settings-to-state-providers";
 import { MoveBiometricUnlockToStateProviders } from "./migrations/28-move-biometric-unlock-to-state-providers";
+import { UserNotificationSettingsKeyMigrator } from "./migrations/29-move-user-notification-settings-to-state-provider";
 import { FixPremiumMigrator } from "./migrations/3-fix-premium";
 import { RemoveEverBeenUnlockedMigrator } from "./migrations/4-remove-ever-been-unlocked";
 import { AddKeyTypeToOrgKeysMigrator } from "./migrations/5-add-key-type-to-org-keys";
@@ -33,7 +34,7 @@ import { MoveBrowserSettingsToGlobal } from "./migrations/9-move-browser-setting
 import { MinVersionMigrator } from "./migrations/min-version";
 
 export const MIN_VERSION = 2;
-export const CURRENT_VERSION = 28;
+export const CURRENT_VERSION = 29;
 export type MinVersion = typeof MIN_VERSION;
 
 export function createMigrationBuilder() {
@@ -64,7 +65,8 @@ export function createMigrationBuilder() {
     .with(ClearClipboardDelayMigrator, 24, 25)
     .with(RevertLastSyncMigrator, 25, 26)
     .with(BadgeSettingsMigrator, 26, 27)
-    .with(MoveBiometricUnlockToStateProviders, 27, CURRENT_VERSION);
+    .with(MoveBiometricUnlockToStateProviders, 27, 28)
+    .with(UserNotificationSettingsKeyMigrator, 28, CURRENT_VERSION);
 }
 
 export async function currentVersion(

libs/common/src/state-migrations/migrations/29-move-user-notification-settings-to-state-provider.spec.ts

@@ -0,0 +1,102 @@
+import { MockProxy } from "jest-mock-extended";
+
+import { StateDefinitionLike, MigrationHelper } from "../migration-helper";
+import { mockMigrationHelper } from "../migration-helper.spec";
+
+import { UserNotificationSettingsKeyMigrator } from "./29-move-user-notification-settings-to-state-provider";
+
+function exampleJSON() {
+  return {
+    global: {
+      disableAddLoginNotification: false,
+      disableChangedPasswordNotification: false,
+      otherStuff: "otherStuff1",
+    },
+  };
+}
+
+function rollbackJSON() {
+  return {
+    global_userNotificationSettings_enableAddedLoginPrompt: true,
+    global_userNotificationSettings_enableChangedPasswordPrompt: true,
+    global: {
+      otherStuff: "otherStuff1",
+    },
+  };
+}
+
+const userNotificationSettingsLocalStateDefinition: {
+  stateDefinition: StateDefinitionLike;
+} = {
+  stateDefinition: {
+    name: "userNotificationSettings",
+  },
+};
+
+describe("ProviderKeysMigrator", () => {
+  let helper: MockProxy<MigrationHelper>;
+  let sut: UserNotificationSettingsKeyMigrator;
+
+  describe("migrate", () => {
+    beforeEach(() => {
+      helper = mockMigrationHelper(exampleJSON(), 28);
+      sut = new UserNotificationSettingsKeyMigrator(28, 29);
+    });
+
+    it("should remove disableAddLoginNotification and disableChangedPasswordNotification global setting", async () => {
+      await sut.migrate(helper);
+      expect(helper.set).toHaveBeenCalledTimes(2);
+      expect(helper.set).toHaveBeenCalledWith("global", { otherStuff: "otherStuff1" });
+      expect(helper.set).toHaveBeenCalledWith("global", { otherStuff: "otherStuff1" });
+    });
+
+    it("should set global user notification setting values", async () => {
+      await sut.migrate(helper);
+
+      expect(helper.setToGlobal).toHaveBeenCalledTimes(2);
+      expect(helper.setToGlobal).toHaveBeenCalledWith(
+        { ...userNotificationSettingsLocalStateDefinition, key: "enableAddedLoginPrompt" },
+        true,
+      );
+      expect(helper.setToGlobal).toHaveBeenCalledWith(
+        { ...userNotificationSettingsLocalStateDefinition, key: "enableChangedPasswordPrompt" },
+        true,
+      );
+    });
+  });
+
+  describe("rollback", () => {
+    beforeEach(() => {
+      helper = mockMigrationHelper(rollbackJSON(), 29);
+      sut = new UserNotificationSettingsKeyMigrator(28, 29);
+    });
+
+    it("should null out new global values", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.setToGlobal).toHaveBeenCalledTimes(2);
+      expect(helper.setToGlobal).toHaveBeenCalledWith(
+        { ...userNotificationSettingsLocalStateDefinition, key: "enableAddedLoginPrompt" },
+        null,
+      );
+      expect(helper.setToGlobal).toHaveBeenCalledWith(
+        { ...userNotificationSettingsLocalStateDefinition, key: "enableChangedPasswordPrompt" },
+        null,
+      );
+    });
+
+    it("should add explicit global values back", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.set).toHaveBeenCalledTimes(2);
+      expect(helper.set).toHaveBeenCalledWith("global", {
+        disableAddLoginNotification: false,
+        otherStuff: "otherStuff1",
+      });
+      expect(helper.set).toHaveBeenCalledWith("global", {
+        disableChangedPasswordNotification: false,
+        otherStuff: "otherStuff1",
+      });
+    });
+  });
+});

libs/common/src/state-migrations/migrations/29-move-user-notification-settings-to-state-provider.ts

@@ -0,0 +1,105 @@
+import { MigrationHelper } from "../migration-helper";
+import { Migrator } from "../migrator";
+
+type ExpectedGlobalState = {
+  disableAddLoginNotification?: boolean;
+  disableChangedPasswordNotification?: boolean;
+};
+
+export class UserNotificationSettingsKeyMigrator extends Migrator<28, 29> {
+  async migrate(helper: MigrationHelper): Promise<void> {
+    const globalState = await helper.get<ExpectedGlobalState>("global");
+
+    // disableAddLoginNotification -> enableAddedLoginPrompt
+    if (globalState?.disableAddLoginNotification != null) {
+      await helper.setToGlobal(
+        {
+          stateDefinition: {
+            name: "userNotificationSettings",
+          },
+          key: "enableAddedLoginPrompt",
+        },
+        !globalState.disableAddLoginNotification,
+      );
+
+      // delete `disableAddLoginNotification` from state global
+      delete globalState.disableAddLoginNotification;
+
+      await helper.set<ExpectedGlobalState>("global", globalState);
+    }
+
+    // disableChangedPasswordNotification -> enableChangedPasswordPrompt
+    if (globalState?.disableChangedPasswordNotification != null) {
+      await helper.setToGlobal(
+        {
+          stateDefinition: {
+            name: "userNotificationSettings",
+          },
+          key: "enableChangedPasswordPrompt",
+        },
+        !globalState.disableChangedPasswordNotification,
+      );
+
+      // delete `disableChangedPasswordNotification` from state global
+      delete globalState.disableChangedPasswordNotification;
+
+      await helper.set<ExpectedGlobalState>("global", globalState);
+    }
+  }
+
+  async rollback(helper: MigrationHelper): Promise<void> {
+    const globalState = (await helper.get<ExpectedGlobalState>("global")) || {};
+
+    const enableAddedLoginPrompt: boolean = await helper.getFromGlobal({
+      stateDefinition: {
+        name: "userNotificationSettings",
+      },
+      key: "enableAddedLoginPrompt",
+    });
+
+    const enableChangedPasswordPrompt: boolean = await helper.getFromGlobal({
+      stateDefinition: {
+        name: "userNotificationSettings",
+      },
+      key: "enableChangedPasswordPrompt",
+    });
+
+    // enableAddedLoginPrompt -> disableAddLoginNotification
+    if (enableAddedLoginPrompt) {
+      await helper.set<ExpectedGlobalState>("global", {
+        ...globalState,
+        disableAddLoginNotification: !enableAddedLoginPrompt,
+      });
+
+      // remove the global state provider framework key for `enableAddedLoginPrompt`
+      await helper.setToGlobal(
+        {
+          stateDefinition: {
+            name: "userNotificationSettings",
+          },
+          key: "enableAddedLoginPrompt",
+        },
+        null,
+      );
+    }
+
+    // enableChangedPasswordPrompt -> disableChangedPasswordNotification
+    if (enableChangedPasswordPrompt) {
+      await helper.set<ExpectedGlobalState>("global", {
+        ...globalState,
+        disableChangedPasswordNotification: !enableChangedPasswordPrompt,
+      });
+
+      // remove the global state provider framework key for `enableChangedPasswordPrompt`
+      await helper.setToGlobal(
+        {
+          stateDefinition: {
+            name: "userNotificationSettings",
+          },
+          key: "enableChangedPasswordPrompt",
+        },
+        null,
+      );
+    }
+  }
+}