[PM-5562] Implement Domain Settings state provider (#8226)

* create domain settings state provider

* replace callsites for defaultUriMatch and neverDomains with DomainSettingsService equivalents

* replace callsites for equivalentDomains with DomainSettingsService equivalents and clean up unused AccountSettingsSettings

* add migrations for domain settings state

* do not use enum for URI match strategy constants and types

* add getUrlEquivalentDomains test

* PR suggestions/cleanup

* refactor getUrlEquivalentDomains to return an observable

Co-authored-by: Justin Baur <19896123+justindbaur@users.noreply.github.com>
Co-authored-by: ✨ Audrey ✨ <ajensen@bitwarden.com>

* update tests

* add UriMatchStrategy docs notes

* service class renames

* use service abstraction at callsites previously using service class directly

---------

Co-authored-by: Justin Baur <19896123+justindbaur@users.noreply.github.com>
Co-authored-by: ✨ Audrey ✨ <ajensen@bitwarden.com>

libs/common/src/autofill/services/domain-settings.service.spec.ts

@@ -0,0 +1,53 @@
+import { firstValueFrom, of } from "rxjs";
+
+import { FakeStateProvider, FakeAccountService, mockAccountServiceWith } from "../../../spec";
+import { Utils } from "../../platform/misc/utils";
+import { UserId } from "../../types/guid";
+
+import { DefaultDomainSettingsService, DomainSettingsService } from "./domain-settings.service";
+
+describe("DefaultDomainSettingsService", () => {
+  let domainSettingsService: DomainSettingsService;
+  const mockUserId = Utils.newGuid() as UserId;
+  const accountService: FakeAccountService = mockAccountServiceWith(mockUserId);
+  const fakeStateProvider: FakeStateProvider = new FakeStateProvider(accountService);
+
+  const mockEquivalentDomains = [
+    ["example.com", "exampleapp.com", "example.co.uk", "ejemplo.es"],
+    ["bitwarden.com", "bitwarden.co.uk", "sm-bitwarden.com"],
+    ["example.co.uk", "exampleapp.co.uk"],
+  ];
+
+  beforeEach(() => {
+    domainSettingsService = new DefaultDomainSettingsService(fakeStateProvider);
+
+    jest.spyOn(domainSettingsService, "getUrlEquivalentDomains");
+    domainSettingsService.equivalentDomains$ = of(mockEquivalentDomains);
+  });
+
+  describe("getUrlEquivalentDomains", () => {
+    it("returns all equivalent domains for a URL", async () => {
+      const expected = new Set([
+        "example.com",
+        "exampleapp.com",
+        "example.co.uk",
+        "ejemplo.es",
+        "exampleapp.co.uk",
+      ]);
+
+      const actual = await firstValueFrom(
+        domainSettingsService.getUrlEquivalentDomains("example.co.uk"),
+      );
+
+      expect(domainSettingsService.getUrlEquivalentDomains).toHaveBeenCalledWith("example.co.uk");
+      expect(actual).toEqual(expected);
+    });
+
+    it("returns an empty set if there are no equivalent domains", async () => {
+      const actual = await firstValueFrom(domainSettingsService.getUrlEquivalentDomains("asdf"));
+
+      expect(domainSettingsService.getUrlEquivalentDomains).toHaveBeenCalledWith("asdf");
+      expect(actual).toEqual(new Set());
+    });
+  });
+});

libs/common/src/autofill/services/domain-settings.service.ts

@@ -0,0 +1,97 @@
+import { map, Observable } from "rxjs";
+
+import {
+  NeverDomains,
+  EquivalentDomains,
+  UriMatchStrategySetting,
+  UriMatchStrategy,
+} from "../../models/domain/domain-service";
+import { Utils } from "../../platform/misc/utils";
+import {
+  DOMAIN_SETTINGS_DISK,
+  ActiveUserState,
+  GlobalState,
+  KeyDefinition,
+  StateProvider,
+  UserKeyDefinition,
+} from "../../platform/state";
+
+const NEVER_DOMAINS = new KeyDefinition(DOMAIN_SETTINGS_DISK, "neverDomains", {
+  deserializer: (value: NeverDomains) => value ?? null,
+});
+
+const EQUIVALENT_DOMAINS = new UserKeyDefinition(DOMAIN_SETTINGS_DISK, "equivalentDomains", {
+  deserializer: (value: EquivalentDomains) => value ?? null,
+  clearOn: ["logout"],
+});
+
+const DEFAULT_URI_MATCH_STRATEGY = new KeyDefinition(
+  DOMAIN_SETTINGS_DISK,
+  "defaultUriMatchStrategy",
+  {
+    deserializer: (value: UriMatchStrategySetting) => value ?? UriMatchStrategy.Domain,
+  },
+);
+
+export abstract class DomainSettingsService {
+  neverDomains$: Observable<NeverDomains>;
+  setNeverDomains: (newValue: NeverDomains) => Promise<void>;
+  equivalentDomains$: Observable<EquivalentDomains>;
+  setEquivalentDomains: (newValue: EquivalentDomains) => Promise<void>;
+  defaultUriMatchStrategy$: Observable<UriMatchStrategySetting>;
+  setDefaultUriMatchStrategy: (newValue: UriMatchStrategySetting) => Promise<void>;
+  getUrlEquivalentDomains: (url: string) => Observable<Set<string>>;
+}
+
+export class DefaultDomainSettingsService implements DomainSettingsService {
+  private neverDomainsState: GlobalState<NeverDomains>;
+  readonly neverDomains$: Observable<NeverDomains>;
+
+  private equivalentDomainsState: ActiveUserState<EquivalentDomains>;
+  readonly equivalentDomains$: Observable<EquivalentDomains>;
+
+  private defaultUriMatchStrategyState: ActiveUserState<UriMatchStrategySetting>;
+  readonly defaultUriMatchStrategy$: Observable<UriMatchStrategySetting>;
+
+  constructor(private stateProvider: StateProvider) {
+    this.neverDomainsState = this.stateProvider.getGlobal(NEVER_DOMAINS);
+    this.neverDomains$ = this.neverDomainsState.state$.pipe(map((x) => x ?? null));
+
+    this.equivalentDomainsState = this.stateProvider.getActive(EQUIVALENT_DOMAINS);
+    this.equivalentDomains$ = this.equivalentDomainsState.state$.pipe(map((x) => x ?? null));
+
+    this.defaultUriMatchStrategyState = this.stateProvider.getActive(DEFAULT_URI_MATCH_STRATEGY);
+    this.defaultUriMatchStrategy$ = this.defaultUriMatchStrategyState.state$.pipe(
+      map((x) => x ?? UriMatchStrategy.Domain),
+    );
+  }
+
+  async setNeverDomains(newValue: NeverDomains): Promise<void> {
+    await this.neverDomainsState.update(() => newValue);
+  }
+
+  async setEquivalentDomains(newValue: EquivalentDomains): Promise<void> {
+    await this.equivalentDomainsState.update(() => newValue);
+  }
+
+  async setDefaultUriMatchStrategy(newValue: UriMatchStrategySetting): Promise<void> {
+    await this.defaultUriMatchStrategyState.update(() => newValue);
+  }
+
+  getUrlEquivalentDomains(url: string): Observable<Set<string>> {
+    const domains$ = this.equivalentDomains$.pipe(
+      map((equivalentDomains) => {
+        const domain = Utils.getDomain(url);
+        if (domain == null || equivalentDomains == null) {
+          return new Set() as Set<string>;
+        }
+
+        const equivalents = equivalentDomains.filter((ed) => ed.includes(domain)).flat();
+
+        return new Set(equivalents);
+      }),
+    );
+
+    return domains$;
+  }
+}