[PM-5272] Migrate CollapsedGroupings to State Provider (#7954)

apps/browser/src/background/main.background.ts

@@ -607,12 +607,12 @@ export default class MainBackground {
     );
 
     this.vaultFilterService = new VaultFilterService(
-      this.stateService,
       this.organizationService,
       this.folderService,
       this.cipherService,
       this.collectionService,
       this.policyService,
+      this.stateProvider,
       this.accountService,
     );
 

apps/browser/src/popup/services/services.module.ts

@@ -427,28 +427,14 @@ function getBgService<T>(service: keyof MainBackground) {
     },
     {
       provide: VaultFilterService,
-      useFactory: (
+      useClass: VaultFilterService,
-        stateService: StateServiceAbstraction,
-        organizationService: OrganizationService,
-        folderService: FolderServiceAbstraction,
-        policyService: PolicyService,
-        accountService: AccountServiceAbstraction,
-      ) => {
-        return new VaultFilterService(
-          stateService,
-          organizationService,
-          folderService,
-          getBgService<CipherService>("cipherService")(),
-          getBgService<CollectionService>("collectionService")(),
-          policyService,
-          accountService,
-        );
-      },
       deps: [
-        StateServiceAbstraction,
         OrganizationService,
         FolderServiceAbstraction,
+        CipherService,
+        CollectionService,
         PolicyService,
+        StateProvider,
         AccountServiceAbstraction,
       ],
     },

apps/browser/src/vault/services/vault-filter.service.ts

@@ -3,7 +3,7 @@ import { VaultFilterService as BaseVaultFilterService } from "@bitwarden/angular
 import { OrganizationService } from "@bitwarden/common/admin-console/abstractions/organization/organization.service.abstraction";
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
-import { StateService } from "@bitwarden/common/platform/abstractions/state.service";
+import { StateProvider } from "@bitwarden/common/platform/state";
 import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
 import { CollectionService } from "@bitwarden/common/vault/abstractions/collection.service";
 import { FolderService } from "@bitwarden/common/vault/abstractions/folder/folder.service.abstraction";
@@ -16,21 +16,21 @@ export class VaultFilterService extends BaseVaultFilterService {
   myVault = "myVault";
 
   constructor(
-    stateService: StateService,
     organizationService: OrganizationService,
     folderService: FolderService,
     cipherService: CipherService,
     collectionService: CollectionService,
     policyService: PolicyService,
+    stateProvider: StateProvider,
     private accountService: AccountService,
   ) {
     super(
-      stateService,
       organizationService,
       folderService,
       cipherService,
       collectionService,
       policyService,
+      stateProvider,
     );
     this.vaultFilter.myVaultOnly = false;
     this.vaultFilter.selectedOrganizationId = null;

apps/web/src/app/vault/individual-vault/vault-filter/services/vault-filter.service.spec.ts

@@ -1,24 +1,31 @@
+import {
+  FakeAccountService,
+  mockAccountServiceWith,
+} from "@bitwarden/common/../spec/fake-account-service";
+import { FakeActiveUserState } from "@bitwarden/common/../spec/fake-state";
+import { FakeStateProvider } from "@bitwarden/common/../spec/fake-state-provider";
 import { mock, MockProxy } from "jest-mock-extended";
-import { firstValueFrom, ReplaySubject, take } from "rxjs";
+import { firstValueFrom, ReplaySubject } from "rxjs";
 
 import { OrganizationService } from "@bitwarden/common/admin-console/abstractions/organization/organization.service.abstraction";
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { PolicyType } from "@bitwarden/common/admin-console/enums";
 import { Organization } from "@bitwarden/common/admin-console/models/domain/organization";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
-import { StateService } from "@bitwarden/common/platform/abstractions/state.service";
+import { Utils } from "@bitwarden/common/platform/misc/utils";
+import { UserId } from "@bitwarden/common/types/guid";
 import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
 import { FolderService } from "@bitwarden/common/vault/abstractions/folder/folder.service.abstraction";
 import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view";
 import { CollectionView } from "@bitwarden/common/vault/models/view/collection.view";
 import { FolderView } from "@bitwarden/common/vault/models/view/folder.view";
+import { COLLAPSED_GROUPINGS } from "@bitwarden/common/vault/services/key-state/collapsed-groupings.state";
 
 import { VaultFilterService } from "./vault-filter.service";
 
 describe("vault filter service", () => {
   let vaultFilterService: VaultFilterService;
 
-  let stateService: MockProxy<StateService>;
   let organizationService: MockProxy<OrganizationService>;
   let folderService: MockProxy<FolderService>;
   let cipherService: MockProxy<CipherService>;
@@ -26,14 +33,20 @@ describe("vault filter service", () => {
   let i18nService: MockProxy<I18nService>;
   let organizations: ReplaySubject<Organization[]>;
   let folderViews: ReplaySubject<FolderView[]>;
+  let stateProvider: FakeStateProvider;
+
+  const mockUserId = Utils.newGuid() as UserId;
+  let accountService: FakeAccountService;
+  let collapsedGroupingsState: FakeActiveUserState<string[]>;
 
   beforeEach(() => {
-    stateService = mock<StateService>();
     organizationService = mock<OrganizationService>();
     folderService = mock<FolderService>();
     cipherService = mock<CipherService>();
     policyService = mock<PolicyService>();
     i18nService = mock<I18nService>();
+    accountService = mockAccountServiceWith(mockUserId);
+    stateProvider = new FakeStateProvider(accountService);
     i18nService.collator = new Intl.Collator("en-US");
 
     organizations = new ReplaySubject<Organization[]>(1);
@@ -43,31 +56,32 @@ describe("vault filter service", () => {
     folderService.folderViews$ = folderViews;
 
     vaultFilterService = new VaultFilterService(
-      stateService,
       organizationService,
       folderService,
       cipherService,
       policyService,
       i18nService,
+      stateProvider,
     );
+    collapsedGroupingsState = stateProvider.activeUser.getFake(COLLAPSED_GROUPINGS);
   });
 
   describe("collapsed filter nodes", () => {
     const nodes = new Set(["1", "2"]);
-    it("updates observable when saving", (complete) => {
-      vaultFilterService.collapsedFilterNodes$.pipe(take(1)).subscribe((value) => {
-        if (value === nodes) {
-          complete();
-        }
-      });
 
-      // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
+    it("should update the collapsedFilterNodes$", async () => {
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      await vaultFilterService.setCollapsedFilterNodes(nodes);
-      vaultFilterService.setCollapsedFilterNodes(nodes);
+
+      const collapsedGroupingsState = stateProvider.activeUser.getFake(COLLAPSED_GROUPINGS);
+      expect(await firstValueFrom(collapsedGroupingsState.state$)).toEqual(Array.from(nodes));
+      expect(collapsedGroupingsState.nextMock).toHaveBeenCalledWith([
+        mockUserId,
+        Array.from(nodes),
+      ]);
     });
 
     it("loads from state on initialization", async () => {
-      stateService.getCollapsedGroupings.mockResolvedValue(["1", "2"]);
+      collapsedGroupingsState.nextState(["1", "2"]);
 
       await expect(firstValueFrom(vaultFilterService.collapsedFilterNodes$)).resolves.toEqual(
         nodes,

apps/web/src/app/vault/individual-vault/vault-filter/services/vault-filter.service.ts

@@ -16,7 +16,7 @@ import { PolicyService } from "@bitwarden/common/admin-console/abstractions/poli
 import { PolicyType } from "@bitwarden/common/admin-console/enums";
 import { Organization } from "@bitwarden/common/admin-console/models/domain/organization";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
-import { StateService } from "@bitwarden/common/platform/abstractions/state.service";
+import { ActiveUserState, StateProvider } from "@bitwarden/common/platform/state";
 import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
 import { FolderService } from "@bitwarden/common/vault/abstractions/folder/folder.service.abstraction";
 import { CipherType } from "@bitwarden/common/vault/enums";
@@ -24,6 +24,7 @@ import { TreeNode } from "@bitwarden/common/vault/models/domain/tree-node";
 import { CollectionView } from "@bitwarden/common/vault/models/view/collection.view";
 import { FolderView } from "@bitwarden/common/vault/models/view/folder.view";
 import { ServiceUtils } from "@bitwarden/common/vault/service-utils";
+import { COLLAPSED_GROUPINGS } from "@bitwarden/common/vault/services/key-state/collapsed-groupings.state";
 
 import { CollectionAdminView } from "../../../core/views/collection-admin.view";
 import {
@@ -39,11 +40,6 @@ const NestingDelimiter = "/";
 
 @Injectable()
 export class VaultFilterService implements VaultFilterServiceAbstraction {
-  protected _collapsedFilterNodes = new BehaviorSubject<Set<string>>(null);
-  collapsedFilterNodes$: Observable<Set<string>> = this._collapsedFilterNodes.pipe(
-    switchMap(async (nodes) => nodes ?? (await this.getCollapsedFilterNodes())),
-  );
-
   organizationTree$: Observable<TreeNode<OrganizationFilter>> =
     this.organizationService.memberOrganizations$.pipe(
       switchMap((orgs) => this.buildOrganizationTree(orgs)),
@@ -78,13 +74,19 @@ export class VaultFilterService implements VaultFilterServiceAbstraction {
 
   cipherTypeTree$: Observable<TreeNode<CipherTypeFilter>> = this.buildCipherTypeTree();
 
+  private collapsedGroupingsState: ActiveUserState<string[]> =
+    this.stateProvider.getActive(COLLAPSED_GROUPINGS);
+
+  readonly collapsedFilterNodes$: Observable<Set<string>> =
+    this.collapsedGroupingsState.state$.pipe(map((c) => new Set(c)));
+
   constructor(
-    protected stateService: StateService,
     protected organizationService: OrganizationService,
     protected folderService: FolderService,
     protected cipherService: CipherService,
     protected policyService: PolicyService,
     protected i18nService: I18nService,
+    protected stateProvider: StateProvider,
   ) {}
 
   async reloadCollections(collections: CollectionView[]) {
@@ -97,13 +99,11 @@ export class VaultFilterService implements VaultFilterServiceAbstraction {
   }
 
   async setCollapsedFilterNodes(collapsedFilterNodes: Set<string>): Promise<void> {
-    await this.stateService.setCollapsedGroupings(Array.from(collapsedFilterNodes));
+    await this.collapsedGroupingsState.update(() => Array.from(collapsedFilterNodes));
-    this._collapsedFilterNodes.next(collapsedFilterNodes);
   }
 
   protected async getCollapsedFilterNodes(): Promise<Set<string>> {
-    const nodes = new Set(await this.stateService.getCollapsedGroupings());
+    return await firstValueFrom(this.collapsedFilterNodes$);
-    return nodes;
   }
 
   getOrganizationFilter() {

apps/web/src/app/vault/org-vault/vault-filter/vault-filter.service.ts

@@ -4,11 +4,11 @@ import { map, Observable, ReplaySubject, Subject } from "rxjs";
 import { OrganizationService } from "@bitwarden/common/admin-console/abstractions/organization/organization.service.abstraction";
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
+import { StateProvider } from "@bitwarden/common/platform/state";
 import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
 import { FolderService } from "@bitwarden/common/vault/abstractions/folder/folder.service.abstraction";
 import { TreeNode } from "@bitwarden/common/vault/models/domain/tree-node";
 
-import { StateService } from "../../../core";
 import { CollectionAdminView } from "../../../vault/core/views/collection-admin.view";
 import { CollectionAdminService } from "../../core/collection-admin.service";
 import { VaultFilterService as BaseVaultFilterService } from "../../individual-vault/vault-filter/services/vault-filter.service";
@@ -26,21 +26,21 @@ export class VaultFilterService extends BaseVaultFilterService implements OnDest
   );
 
   constructor(
-    stateService: StateService,
     organizationService: OrganizationService,
     folderService: FolderService,
     cipherService: CipherService,
     policyService: PolicyService,
     i18nService: I18nService,
+    stateProvider: StateProvider,
     protected collectionAdminService: CollectionAdminService,
   ) {
     super(
-      stateService,
       organizationService,
       folderService,
       cipherService,
       policyService,
       i18nService,
+      stateProvider,
     );
   }
 

libs/angular/src/vault/vault-filter/services/vault-filter.service.ts

@@ -1,5 +1,5 @@
 import { Injectable } from "@angular/core";
-import { firstValueFrom, from, mergeMap, Observable } from "rxjs";
+import { firstValueFrom, from, map, mergeMap, Observable } from "rxjs";
 
 import {
   isMember,
@@ -8,7 +8,7 @@ import {
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { PolicyType } from "@bitwarden/common/admin-console/enums";
 import { Organization } from "@bitwarden/common/admin-console/models/domain/organization";
-import { StateService } from "@bitwarden/common/platform/abstractions/state.service";
+import { ActiveUserState, StateProvider } from "@bitwarden/common/platform/state";
 import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
 import { CollectionService } from "@bitwarden/common/vault/abstractions/collection.service";
 import { FolderService } from "@bitwarden/common/vault/abstractions/folder/folder.service.abstraction";
@@ -20,25 +20,32 @@ import { ServiceUtils } from "@bitwarden/common/vault/service-utils";
 import { DeprecatedVaultFilterService as DeprecatedVaultFilterServiceAbstraction } from "../../abstractions/deprecated-vault-filter.service";
 import { DynamicTreeNode } from "../models/dynamic-tree-node.model";
 
+import { COLLAPSED_GROUPINGS } from "./../../../../../common/src/vault/services/key-state/collapsed-groupings.state";
+
 const NestingDelimiter = "/";
 
 @Injectable()
 export class VaultFilterService implements DeprecatedVaultFilterServiceAbstraction {
+  private collapsedGroupingsState: ActiveUserState<string[]> =
+    this.stateProvider.getActive(COLLAPSED_GROUPINGS);
+  private readonly collapsedGroupings$: Observable<Set<string>> =
+    this.collapsedGroupingsState.state$.pipe(map((c) => new Set(c)));
+
   constructor(
-    protected stateService: StateService,
     protected organizationService: OrganizationService,
     protected folderService: FolderService,
     protected cipherService: CipherService,
     protected collectionService: CollectionService,
     protected policyService: PolicyService,
+    protected stateProvider: StateProvider,
   ) {}
 
   async storeCollapsedFilterNodes(collapsedFilterNodes: Set<string>): Promise<void> {
-    await this.stateService.setCollapsedGroupings(Array.from(collapsedFilterNodes));
+    await this.collapsedGroupingsState.update(() => Array.from(collapsedFilterNodes));
   }
 
   async buildCollapsedFilterNodes(): Promise<Set<string>> {
-    return new Set(await this.stateService.getCollapsedGroupings());
+    return await firstValueFrom(this.collapsedGroupings$);
   }
 
   async buildOrganizations(): Promise<Organization[]> {

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

@@ -80,8 +80,6 @@ export abstract class StateService<T extends Account = Account> {
   getHasPremiumFromOrganization: (options?: StorageOptions) => Promise<boolean>;
   getClearClipboard: (options?: StorageOptions) => Promise<number>;
   setClearClipboard: (value: number, options?: StorageOptions) => Promise<void>;
-  getCollapsedGroupings: (options?: StorageOptions) => Promise<string[]>;
-  setCollapsedGroupings: (value: string[], options?: StorageOptions) => Promise<void>;
   getConvertAccountToKeyConnector: (options?: StorageOptions) => Promise<boolean>;
   setConvertAccountToKeyConnector: (value: boolean, options?: StorageOptions) => Promise<void>;
   /**

libs/common/src/platform/models/domain/account.ts

@@ -22,7 +22,6 @@ import { DeepJsonify } from "../../../types/deep-jsonify";
 import { MasterKey, UserKey } from "../../../types/key";
 import { UriMatchType } from "../../../vault/enums";
 import { CipherData } from "../../../vault/models/data/cipher.data";
-import { FolderData } from "../../../vault/models/data/folder.data";
 import { CipherView } from "../../../vault/models/view/cipher.view";
 import { AddEditCipherInfo } from "../../../vault/types/add-edit-cipher-info";
 import { KdfType } from "../../enums";
@@ -87,7 +86,6 @@ export class AccountData {
     CipherData,
     CipherView
   >();
-  folders? = new TemporaryDataEncryption<FolderData>();
   localData?: any;
   sends?: DataEncryptionPair<SendData, SendView> = new DataEncryptionPair<SendData, SendView>();
   policies?: DataEncryptionPair<PolicyData, Policy> = new DataEncryptionPair<PolicyData, Policy>();
@@ -206,7 +204,6 @@ export class AccountSettings {
   autoConfirmFingerPrints?: boolean;
   biometricUnlock?: boolean;
   clearClipboard?: number;
-  collapsedGroupings?: string[];
   defaultUriMatch?: UriMatchType;
   disableAutoBiometricsPrompt?: boolean;
   disableBadgeCounter?: boolean;

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

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

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

@@ -495,23 +495,6 @@ export class StateService<
     );
   }
 
-  async getCollapsedGroupings(options?: StorageOptions): Promise<string[]> {
-    return (
-      await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()))
-    )?.settings?.collapsedGroupings;
-  }
-
-  async setCollapsedGroupings(value: string[], options?: StorageOptions): Promise<void> {
-    const account = await this.getAccount(
-      this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-    );
-    account.settings.collapsedGroupings = value;
-    await this.saveAccount(
-      account,
-      this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-    );
-  }
-
   async getConvertAccountToKeyConnector(options?: StorageOptions): Promise<boolean> {
     return (
       await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()))

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

@@ -57,3 +57,7 @@ export const AUTOFILL_SETTINGS_DISK = new StateDefinition("autofillSettings", "d
 export const AUTOFILL_SETTINGS_DISK_LOCAL = new StateDefinition("autofillSettingsLocal", "disk", {
   web: "disk-local",
 });
+
+export const VAULT_FILTER_DISK = new StateDefinition("vaultFilter", "disk", {
+  web: "disk-local",
+});

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

@@ -16,6 +16,7 @@ import { AutofillSettingsKeyMigrator } from "./migrations/18-move-autofill-setti
 import { RequirePasswordOnStartMigrator } from "./migrations/19-migrate-require-password-on-start";
 import { PrivateKeyMigrator } from "./migrations/20-move-private-key-to-state-providers";
 import { CollectionMigrator } from "./migrations/21-move-collections-state-to-state-provider";
+import { CollapsedGroupingsMigrator } from "./migrations/22-move-collapsed-groupings-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";
@@ -26,7 +27,7 @@ import { MoveBrowserSettingsToGlobal } from "./migrations/9-move-browser-setting
 import { MinVersionMigrator } from "./migrations/min-version";
 
 export const MIN_VERSION = 2;
-export const CURRENT_VERSION = 21;
+export const CURRENT_VERSION = 22;
 export type MinVersion = typeof MIN_VERSION;
 
 export function createMigrationBuilder() {
@@ -50,7 +51,8 @@ export function createMigrationBuilder() {
     .with(AutofillSettingsKeyMigrator, 17, 18)
     .with(RequirePasswordOnStartMigrator, 18, 19)
     .with(PrivateKeyMigrator, 19, 20)
-    .with(CollectionMigrator, 20, CURRENT_VERSION);
+    .with(CollectionMigrator, 20, 21)
+    .with(CollapsedGroupingsMigrator, 21, CURRENT_VERSION);
 }
 
 export async function currentVersion(

libs/common/src/state-migrations/migrations/22-move-collapsed-groupings-to-state-provider.spec.ts

@@ -0,0 +1,118 @@
+import { MockProxy, any } from "jest-mock-extended";
+
+import { MigrationHelper } from "../migration-helper";
+import { mockMigrationHelper } from "../migration-helper.spec";
+
+import { CollapsedGroupingsMigrator } from "./22-move-collapsed-groupings-to-state-provider";
+
+function exampleJSON() {
+  return {
+    global: {
+      otherStuff: "otherStuff1",
+    },
+    authenticatedAccounts: ["user-1", "user-2", "user-3"],
+    "user-1": {
+      settings: {
+        collapsedGroupings: ["grouping-1", "grouping-2"],
+        otherStuff: "otherStuff2",
+      },
+      otherStuff: "otherStuff3",
+    },
+    "user-2": {
+      settings: {
+        otherStuff: "otherStuff4",
+      },
+      otherStuff: "otherStuff5",
+    },
+  };
+}
+
+function rollbackJSON() {
+  return {
+    "user_user-1_vaultFilter_collapsedGroupings": ["grouping-1", "grouping-2"],
+    global: {
+      otherStuff: "otherStuff1",
+    },
+    authenticatedAccounts: ["user-1", "user-2"],
+    "user-1": {
+      settings: {
+        otherStuff: "otherStuff2",
+      },
+      otherStuff: "otherStuff3",
+    },
+    "user-2": {
+      settings: {
+        otherStuff: "otherStuff4",
+      },
+      otherStuff: "otherStuff5",
+    },
+  };
+}
+
+describe("CollapsedGroupingsMigrator", () => {
+  let helper: MockProxy<MigrationHelper>;
+  let sut: CollapsedGroupingsMigrator;
+  const keyDefinitionLike = {
+    key: "collapsedGroupings",
+    stateDefinition: {
+      name: "vaultFilter",
+    },
+  };
+
+  describe("migrate", () => {
+    beforeEach(() => {
+      helper = mockMigrationHelper(exampleJSON(), 21);
+      sut = new CollapsedGroupingsMigrator(21, 22);
+    });
+
+    it("should remove collapsedGroupings from all accounts", async () => {
+      await sut.migrate(helper);
+      expect(helper.set).toHaveBeenCalledWith("user-1", {
+        settings: {
+          otherStuff: "otherStuff2",
+        },
+        otherStuff: "otherStuff3",
+      });
+    });
+
+    it("should set collapsedGroupings values for each account", async () => {
+      await sut.migrate(helper);
+
+      expect(helper.setToUser).toHaveBeenCalledWith("user-1", keyDefinitionLike, [
+        "grouping-1",
+        "grouping-2",
+      ]);
+    });
+  });
+
+  describe("rollback", () => {
+    beforeEach(() => {
+      helper = mockMigrationHelper(rollbackJSON(), 22);
+      sut = new CollapsedGroupingsMigrator(21, 22);
+    });
+
+    it.each(["user-1", "user-2"])("should null out new values", async (userId) => {
+      await sut.rollback(helper);
+      expect(helper.setToUser).toHaveBeenCalledWith(userId, keyDefinitionLike, null);
+    });
+
+    it("should add explicit value back to accounts", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.set).toHaveBeenCalledTimes(2);
+      expect(helper.set).toHaveBeenCalledWith("user-1", {
+        settings: {
+          collapsedGroupings: ["grouping-1", "grouping-2"],
+          otherStuff: "otherStuff2",
+        },
+        otherStuff: "otherStuff3",
+      });
+    });
+
+    it("should not try to restore values to missing accounts", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.set).not.toHaveBeenCalledWith("user-3", any());
+    });
+  });
+});

libs/common/src/state-migrations/migrations/22-move-collapsed-groupings-to-state-provider.ts

@@ -0,0 +1,47 @@
+import { KeyDefinitionLike, MigrationHelper } from "../migration-helper";
+import { Migrator } from "../migrator";
+
+type ExpectedAccountType = {
+  settings?: {
+    collapsedGroupings?: string[];
+  };
+};
+
+const COLLAPSED_GROUPINGS: KeyDefinitionLike = {
+  key: "collapsedGroupings",
+  stateDefinition: {
+    name: "vaultFilter",
+  },
+};
+
+export class CollapsedGroupingsMigrator extends Migrator<21, 22> {
+  async migrate(helper: MigrationHelper): Promise<void> {
+    const accounts = await helper.getAccounts<ExpectedAccountType>();
+    async function migrateAccount(userId: string, account: ExpectedAccountType): Promise<void> {
+      const value = account?.settings?.collapsedGroupings;
+      if (value != null) {
+        await helper.setToUser(userId, COLLAPSED_GROUPINGS, value);
+        delete account.settings.collapsedGroupings;
+        await helper.set(userId, account);
+      }
+    }
+
+    await Promise.all([...accounts.map(({ userId, account }) => migrateAccount(userId, account))]);
+  }
+
+  async rollback(helper: MigrationHelper): Promise<void> {
+    const accounts = await helper.getAccounts<ExpectedAccountType>();
+    async function rollbackAccount(userId: string, account: ExpectedAccountType): Promise<void> {
+      const value = await helper.getFromUser(userId, COLLAPSED_GROUPINGS);
+      if (account) {
+        account.settings = Object.assign(account.settings ?? {}, {
+          collapsedGroupings: value,
+        });
+        await helper.set(userId, account);
+      }
+      await helper.setToUser(userId, COLLAPSED_GROUPINGS, null);
+    }
+
+    await Promise.all([...accounts.map(({ userId, account }) => rollbackAccount(userId, account))]);
+  }
+}

libs/common/src/vault/services/key-state/collapsed-groupings.state.ts

@@ -0,0 +1,9 @@
+import { KeyDefinition, VAULT_FILTER_DISK } from "../../../platform/state";
+
+export const COLLAPSED_GROUPINGS = KeyDefinition.array<string>(
+  VAULT_FILTER_DISK,
+  "collapsedGroupings",
+  {
+    deserializer: (obj) => obj,
+  },
+);