bitwarden/browser
1
0
Fork 0
mirror of https://github.com/bitwarden/browser synced 2025-12-15 07:43:35 +00:00
Code Issues Releases Wiki Activity

[PM-5276] Migrate FolderService to state providers (#7682)

Browse Source 
* added state definitionand key definition for folder service

* added data migrations

* created folder to house key definitions

* deleted browser-folder-service and added state provider to the browser

* exposed decrypt function so it can be used by the key definition, updated folder service to use state provider

* removed memory since derived state is now used

* updated test cases

* updated test cases

* updated migrations after merge conflict fix

* added state provider to the folder service constructor

* renamed migration file

* updated comments

* updated comments

* removed service registartion from browser service module and removed unused set and get encrypted folders from state service

* renamed files

* added storage location overides and removed extra methods
This commit is contained in:
SmithThe4th
2024-02-06 14:51:02 -05:00
committed by GitHub
parent f64092cc90
commit 7e00ece092
19 changed files with 473 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
libs/common/src/vault/services/folder/folder.service.ts
View File

@@ -1,53 +1,50 @@
import { BehaviorSubject, concatMap } from "rxjs";
import { Observable, firstValueFrom, map } from "rxjs";
import { CryptoService } from "../../../platform/abstractions/crypto.service";
import { I18nService } from "../../../platform/abstractions/i18n.service";
import { StateService } from "../../../platform/abstractions/state.service";
import { Utils } from "../../../platform/misc/utils";
import { SymmetricCryptoKey } from "../../../platform/models/domain/symmetric-crypto-key";
import { ActiveUserState, DerivedState, StateProvider } from "../../../platform/state";
import { UserId } from "../../../types/guid";
import { CipherService } from "../../../vault/abstractions/cipher.service";
import { InternalFolderService as InternalFolderServiceAbstraction } from "../../../vault/abstractions/folder/folder.service.abstraction";
import { CipherData } from "../../../vault/models/data/cipher.data";
import { FolderData } from "../../../vault/models/data/folder.data";
import { Folder } from "../../../vault/models/domain/folder";
import { FolderView } from "../../../vault/models/view/folder.view";
import { FOLDER_DECRYPTED_FOLDERS, FOLDER_ENCRYPTED_FOLDERS } from "../key-state/folder.state";
export class FolderService implements InternalFolderServiceAbstraction {
protected _folders: BehaviorSubject<Folder[]> = new BehaviorSubject([]);
protected _folderViews: BehaviorSubject<FolderView[]> = new BehaviorSubject([]);
folders$: Observable<Folder[]>;
folderViews$: Observable<FolderView[]>;
folders$ = this._folders.asObservable();
folderViews$ = this._folderViews.asObservable();
private encryptedFoldersState: ActiveUserState<Record<string, FolderData>>;
private decryptedFoldersState: DerivedState<FolderView[]>;
constructor(
private cryptoService: CryptoService,
private i18nService: I18nService,
private cipherService: CipherService,
private stateService: StateService,
private stateProvider: StateProvider,
) {
this.stateService.activeAccountUnlocked$
.pipe(
concatMap(async (unlocked) => {
if (Utils.global.bitwardenContainerService == null) {
return;
}
this.encryptedFoldersState = this.stateProvider.getActive(FOLDER_ENCRYPTED_FOLDERS);
this.decryptedFoldersState = this.stateProvider.getDerived(
this.encryptedFoldersState.state$,
FOLDER_DECRYPTED_FOLDERS,
{ folderService: this, cryptoService: this.cryptoService },
);
if (!unlocked) {
this._folders.next([]);
this._folderViews.next([]);
return;
}
this.folders$ = this.encryptedFoldersState.state$.pipe(
map((folderData) => Object.values(folderData).map((f) => new Folder(f))),
);
const data = await this.stateService.getEncryptedFolders();
await this.updateObservables(data);
}),
)
.subscribe();
this.folderViews$ = this.decryptedFoldersState.state$;
}
async clearCache(): Promise<void> {
this._folderViews.next([]);
await this.decryptedFoldersState.forceValue([]);
}
// TODO: This should be moved to EncryptService or something
@@ -59,21 +56,13 @@ export class FolderService implements InternalFolderServiceAbstraction {
}
async get(id: string): Promise<Folder> {
const folders = this._folders.getValue();
const folders = await firstValueFrom(this.folders$);
return folders.find((folder) => folder.id === id);
}
async getAllFromState(): Promise<Folder[]> {
const folders = await this.stateService.getEncryptedFolders();
const response: Folder[] = [];
for (const id in folders) {
// eslint-disable-next-line
if (folders.hasOwnProperty(id)) {
response.push(new Folder(folders[id]));
}
}
return response;
return await firstValueFrom(this.folders$);
}
/**
@@ -81,76 +70,78 @@ export class FolderService implements InternalFolderServiceAbstraction {
* @param id id of the folder
*/
async getFromState(id: string): Promise<Folder> {
const foldersMap = await this.stateService.getEncryptedFolders();
const folder = foldersMap[id];
if (folder == null) {
const folder = await this.get(id);
if (!folder) {
return null;
}
return new Folder(folder);
return folder;
}
/**
* @deprecated Only use in CLI!
*/
async getAllDecryptedFromState(): Promise<FolderView[]> {
const data = await this.stateService.getEncryptedFolders();
const folders = Object.values(data || {}).map((f) => new Folder(f));
return this.decryptFolders(folders);
return await firstValueFrom(this.folderViews$);
}
async upsert(folder: FolderData | FolderData[]): Promise<void> {
let folders = await this.stateService.getEncryptedFolders();
if (folders == null) {
folders = {};
}
async upsert(folderData: FolderData | FolderData[]): Promise<void> {
await this.encryptedFoldersState.update((folders) => {
if (folders == null) {
folders = {};
}
if (folder instanceof FolderData) {
const f = folder as FolderData;
folders[f.id] = f;
} else {
(folder as FolderData[]).forEach((f) => {
if (folderData instanceof FolderData) {
const f = folderData as FolderData;
folders[f.id] = f;
});
}
} else {
(folderData as FolderData[]).forEach((f) => {
folders[f.id] = f;
});
}
await this.updateObservables(folders);
await this.stateService.setEncryptedFolders(folders);
return folders;
});
}
async replace(folders: { [id: string]: FolderData }): Promise<void> {
await this.updateObservables(folders);
await this.stateService.setEncryptedFolders(folders);
}
async clear(userId?: string): Promise<any> {
if (userId == null || userId == (await this.stateService.getUserId())) {
this._folders.next([]);
this._folderViews.next([]);
}
await this.stateService.setEncryptedFolders(null, { userId: userId });
}
async delete(id: string | string[]): Promise<any> {
const folders = await this.stateService.getEncryptedFolders();
if (folders == null) {
if (!folders) {
return;
}
if (typeof id === "string") {
if (folders[id] == null) {
await this.encryptedFoldersState.update(() => {
const newFolders: Record<string, FolderData> = { ...folders };
return newFolders;
});
}
async clear(userId?: UserId): Promise<void> {
if (userId == null) {
await this.encryptedFoldersState.update(() => ({}));
await this.decryptedFoldersState.forceValue([]);
} else {
await this.stateProvider.getUser(userId, FOLDER_ENCRYPTED_FOLDERS).update(() => ({}));
}
}
async delete(id: string | string[]): Promise<any> {
await this.encryptedFoldersState.update((folders) => {
if (folders == null) {
return;
}
delete folders[id];
} else {
(id as string[]).forEach((i) => {
delete folders[i];
});
}
await this.updateObservables(folders);
await this.stateService.setEncryptedFolders(folders);
if (typeof id === "string") {
if (folders[id] == null) {
return;
}
delete folders[id];
} else {
(id as string[]).forEach((i) => {
delete folders[i];
});
}
return folders;
});
// Items in a deleted folder are re-assigned to "No Folder"
const ciphers = await this.stateService.getEncryptedCiphers();
@@ -170,17 +161,7 @@ export class FolderService implements InternalFolderServiceAbstraction {
}
}
private async updateObservables(foldersMap: { [id: string]: FolderData }) {
const folders = Object.values(foldersMap || {}).map((f) => new Folder(f));
this._folders.next(folders);
if (await this.cryptoService.hasUserKey()) {
this._folderViews.next(await this.decryptFolders(folders));
}
}
private async decryptFolders(folders: Folder[]) {
async decryptFolders(folders: Folder[]) {
const decryptFolderPromises = folders.map((f) => f.decrypt());
const decryptedFolders = await Promise.all(decryptFolderPromises);
@@ -189,7 +170,6 @@ export class FolderService implements InternalFolderServiceAbstraction {
const noneFolder = new FolderView();
noneFolder.name = this.i18nService.t("noneFolder");
decryptedFolders.push(noneFolder);
return decryptedFolders;
}
}