[SG-998] and [SG-999] Vault and Autofill team refactor (#4542)

* Move DeprecatedVaultFilterService to vault folder

* [libs] move VaultItemsComponent

* [libs] move AddEditComponent

* [libs] move AddEditCustomFields

* [libs] move attachmentsComponent

* [libs] folderAddEditComponent

* [libs] IconComponent

* [libs] PasswordRepormptComponent

* [libs] PremiumComponent

* [libs] ViewCustomFieldsComponent

* [libs] ViewComponent

* [libs] PasswordRepromptService

* [libs] Move FolderService and FolderApiService abstractions

* [libs] FolderService imports

* [libs] PasswordHistoryComponent

* [libs] move Sync and SyncNotifier abstractions

* [libs] SyncService imports

* [libs] fix file casing for passwordReprompt abstraction

* [libs] SyncNotifier import fix

* [libs] CipherServiceAbstraction

* [libs] PasswordRepromptService abstraction

* [libs] Fix file casing for angular passwordReprompt service

* [libs] fix file casing for SyncNotifierService

* [libs] CipherRepromptType

* [libs] rename CipherRepromptType

* [libs] CipherType

* [libs] Rename CipherType

* [libs] CipherData

* [libs] FolderData

* [libs] PasswordHistoryData

* [libs] AttachmentData

* [libs] CardData

* [libs] FieldData

* [libs] IdentityData

* [libs] LocalData

* [libs] LoginData

* [libs] SecureNoteData

* [libs] LoginUriData

* [libs] Domain classes

* [libs] SecureNote

* [libs] Request models

* [libs] Response models

* [libs] View part 1

* [libs] Views part 2

* [libs] Move folder services

* [libs] Views fixes

* [libs] Move sync services

* [libs] cipher service

* [libs] Types

* [libs] Sync file casing

* [libs] Fix folder service import

* [libs] Move spec files

* [libs] casing fixes on spec files

* [browser] Autofill background, clipboard, commands

* [browser] Fix ContextMenusBackground casing

* [browser] Rename fix

* [browser] Autofill content

* [browser] autofill.js

* [libs] enpass importer spec fix

* [browser] autofill models

* [browser] autofill manifest path updates

* [browser] Autofill notification files

* [browser] autofill services

* [browser] Fix file casing

* [browser] Vault popup loose components

* [browser] Vault components

* [browser] Manifest fixes

* [browser] Vault services

* [cli] vault commands and models

* [browser] File capitilization fixes

* [desktop] Vault components and services

* [web] vault loose components

* [web] Vault components

* [browser] Fix misc-utils import

* [libs] Fix psono spec imports

* [fix] Add comments to address lint rules

libs/common/spec/services/cipher.service.spec.ts

@@ -1,73 +0,0 @@
-// eslint-disable-next-line no-restricted-imports
-import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
-
-import { ApiService } from "@bitwarden/common/abstractions/api.service";
-import { CryptoService } from "@bitwarden/common/abstractions/crypto.service";
-import { EncryptService } from "@bitwarden/common/abstractions/encrypt.service";
-import { FileUploadService } from "@bitwarden/common/abstractions/fileUpload.service";
-import { I18nService } from "@bitwarden/common/abstractions/i18n.service";
-import { LogService } from "@bitwarden/common/abstractions/log.service";
-import { SearchService } from "@bitwarden/common/abstractions/search.service";
-import { SettingsService } from "@bitwarden/common/abstractions/settings.service";
-import { StateService } from "@bitwarden/common/abstractions/state.service";
-import { Cipher } from "@bitwarden/common/models/domain/cipher";
-import { EncArrayBuffer } from "@bitwarden/common/models/domain/enc-array-buffer";
-import { EncString } from "@bitwarden/common/models/domain/enc-string";
-import { SymmetricCryptoKey } from "@bitwarden/common/models/domain/symmetric-crypto-key";
-import { CipherService } from "@bitwarden/common/services/cipher.service";
-
-const ENCRYPTED_TEXT = "This data has been encrypted";
-const ENCRYPTED_BYTES = Substitute.for<EncArrayBuffer>();
-
-describe("Cipher Service", () => {
-  let cryptoService: SubstituteOf<CryptoService>;
-  let stateService: SubstituteOf<StateService>;
-  let settingsService: SubstituteOf<SettingsService>;
-  let apiService: SubstituteOf<ApiService>;
-  let fileUploadService: SubstituteOf<FileUploadService>;
-  let i18nService: SubstituteOf<I18nService>;
-  let searchService: SubstituteOf<SearchService>;
-  let logService: SubstituteOf<LogService>;
-  let encryptService: SubstituteOf<EncryptService>;
-
-  let cipherService: CipherService;
-
-  beforeEach(() => {
-    cryptoService = Substitute.for<CryptoService>();
-    stateService = Substitute.for<StateService>();
-    settingsService = Substitute.for<SettingsService>();
-    apiService = Substitute.for<ApiService>();
-    fileUploadService = Substitute.for<FileUploadService>();
-    i18nService = Substitute.for<I18nService>();
-    searchService = Substitute.for<SearchService>();
-    logService = Substitute.for<LogService>();
-    encryptService = Substitute.for<EncryptService>();
-
-    cryptoService.encryptToBytes(Arg.any(), Arg.any()).resolves(ENCRYPTED_BYTES);
-    cryptoService.encrypt(Arg.any(), Arg.any()).resolves(new EncString(ENCRYPTED_TEXT));
-
-    cipherService = new CipherService(
-      cryptoService,
-      settingsService,
-      apiService,
-      fileUploadService,
-      i18nService,
-      () => searchService,
-      logService,
-      stateService,
-      encryptService
-    );
-  });
-
-  it("attachments upload encrypted file contents", async () => {
-    const fileName = "filename";
-    const fileData = new Uint8Array(10).buffer;
-    cryptoService.getOrgKey(Arg.any()).resolves(new SymmetricCryptoKey(new Uint8Array(32).buffer));
-
-    await cipherService.saveAttachmentRawWithServer(new Cipher(), fileName, fileData);
-
-    fileUploadService
-      .received(1)
-      .uploadCipherAttachment(Arg.any(), Arg.any(), new EncString(ENCRYPTED_TEXT), ENCRYPTED_BYTES);
-  });
-});

libs/common/spec/services/export.service.spec.ts

@@ -2,22 +2,22 @@
 import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
 
 import { ApiService } from "@bitwarden/common/abstractions/api.service";
-import { CipherService } from "@bitwarden/common/abstractions/cipher.service";
 import { CryptoService } from "@bitwarden/common/abstractions/crypto.service";
 import { CryptoFunctionService } from "@bitwarden/common/abstractions/cryptoFunction.service";
-import { FolderService } from "@bitwarden/common/abstractions/folder/folder.service.abstraction";
-import { CipherType } from "@bitwarden/common/enums/cipherType";
 import { KdfType, DEFAULT_PBKDF2_ITERATIONS } from "@bitwarden/common/enums/kdfType";
 import { Utils } from "@bitwarden/common/misc/utils";
-import { Cipher } from "@bitwarden/common/models/domain/cipher";
 import { EncString } from "@bitwarden/common/models/domain/enc-string";
-import { Folder } from "@bitwarden/common/models/domain/folder";
-import { Login } from "@bitwarden/common/models/domain/login";
 import { CipherWithIdExport as CipherExport } from "@bitwarden/common/models/export/cipher-with-ids.export";
-import { CipherView } from "@bitwarden/common/models/view/cipher.view";
-import { FolderView } from "@bitwarden/common/models/view/folder.view";
-import { LoginView } from "@bitwarden/common/models/view/login.view";
 import { ExportService } from "@bitwarden/common/services/export.service";
+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/cipher-type";
+import { Cipher } from "@bitwarden/common/vault/models/domain/cipher";
+import { Folder } from "@bitwarden/common/vault/models/domain/folder";
+import { Login } from "@bitwarden/common/vault/models/domain/login";
+import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view";
+import { FolderView } from "@bitwarden/common/vault/models/view/folder.view";
+import { LoginView } from "@bitwarden/common/vault/models/view/login.view";
 
 import { BuildTestObject, GetUniqueString } from "../utils";
 

libs/common/spec/services/folder.service.spec.ts

@@ -1,202 +0,0 @@
-// eslint-disable-next-line no-restricted-imports
-import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
-import { BehaviorSubject, firstValueFrom } from "rxjs";
-
-import { CipherService } from "@bitwarden/common/abstractions/cipher.service";
-import { CryptoService } from "@bitwarden/common/abstractions/crypto.service";
-import { EncryptService } from "@bitwarden/common/abstractions/encrypt.service";
-import { I18nService } from "@bitwarden/common/abstractions/i18n.service";
-import { FolderData } from "@bitwarden/common/models/data/folder.data";
-import { EncString } from "@bitwarden/common/models/domain/enc-string";
-import { FolderView } from "@bitwarden/common/models/view/folder.view";
-import { ContainerService } from "@bitwarden/common/services/container.service";
-import { FolderService } from "@bitwarden/common/services/folder/folder.service";
-import { StateService } from "@bitwarden/common/services/state.service";
-
-describe("Folder Service", () => {
-  let folderService: FolderService;
-
-  let cryptoService: SubstituteOf<CryptoService>;
-  let encryptService: SubstituteOf<EncryptService>;
-  let i18nService: SubstituteOf<I18nService>;
-  let cipherService: SubstituteOf<CipherService>;
-  let stateService: SubstituteOf<StateService>;
-  let activeAccount: BehaviorSubject<string>;
-  let activeAccountUnlocked: BehaviorSubject<boolean>;
-
-  beforeEach(() => {
-    cryptoService = Substitute.for();
-    encryptService = Substitute.for();
-    i18nService = Substitute.for();
-    cipherService = Substitute.for();
-    stateService = Substitute.for();
-    activeAccount = new BehaviorSubject("123");
-    activeAccountUnlocked = new BehaviorSubject(true);
-
-    stateService.getEncryptedFolders().resolves({
-      "1": folderData("1", "test"),
-    });
-    stateService.activeAccount$.returns(activeAccount);
-    stateService.activeAccountUnlocked$.returns(activeAccountUnlocked);
-    (window as any).bitwardenContainerService = new ContainerService(cryptoService, encryptService);
-
-    folderService = new FolderService(cryptoService, i18nService, cipherService, stateService);
-  });
-
-  it("encrypt", async () => {
-    const model = new FolderView();
-    model.id = "2";
-    model.name = "Test Folder";
-
-    cryptoService.encrypt(Arg.any()).resolves(new EncString("ENC"));
-    cryptoService.decryptToUtf8(Arg.any()).resolves("DEC");
-
-    const result = await folderService.encrypt(model);
-
-    expect(result).toEqual({
-      id: "2",
-      name: {
-        encryptedString: "ENC",
-        encryptionType: 0,
-      },
-    });
-  });
-
-  describe("get", () => {
-    it("exists", async () => {
-      const result = await folderService.get("1");
-
-      expect(result).toEqual({
-        id: "1",
-        name: {
-          decryptedValue: [],
-          encryptedString: "test",
-          encryptionType: 0,
-        },
-        revisionDate: null,
-      });
-    });
-
-    it("not exists", async () => {
-      const result = await folderService.get("2");
-
-      expect(result).toBe(undefined);
-    });
-  });
-
-  it("upsert", async () => {
-    await folderService.upsert(folderData("2", "test 2"));
-
-    expect(await firstValueFrom(folderService.folders$)).toEqual([
-      {
-        id: "1",
-        name: {
-          decryptedValue: [],
-          encryptedString: "test",
-          encryptionType: 0,
-        },
-        revisionDate: null,
-      },
-      {
-        id: "2",
-        name: {
-          decryptedValue: [],
-          encryptedString: "test 2",
-          encryptionType: 0,
-        },
-        revisionDate: null,
-      },
-    ]);
-
-    expect(await firstValueFrom(folderService.folderViews$)).toEqual([
-      { id: "1", name: [], revisionDate: null },
-      { id: "2", name: [], revisionDate: null },
-      { id: null, name: [], revisionDate: null },
-    ]);
-  });
-
-  it("replace", async () => {
-    await folderService.replace({ "2": folderData("2", "test 2") });
-
-    expect(await firstValueFrom(folderService.folders$)).toEqual([
-      {
-        id: "2",
-        name: {
-          decryptedValue: [],
-          encryptedString: "test 2",
-          encryptionType: 0,
-        },
-        revisionDate: null,
-      },
-    ]);
-
-    expect(await firstValueFrom(folderService.folderViews$)).toEqual([
-      { id: "2", name: [], revisionDate: null },
-      { id: null, name: [], revisionDate: null },
-    ]);
-  });
-
-  it("delete", async () => {
-    await folderService.delete("1");
-
-    expect((await firstValueFrom(folderService.folders$)).length).toBe(0);
-
-    expect(await firstValueFrom(folderService.folderViews$)).toEqual([
-      { id: null, name: [], revisionDate: null },
-    ]);
-  });
-
-  it("clearCache", async () => {
-    await folderService.clearCache();
-
-    expect((await firstValueFrom(folderService.folders$)).length).toBe(1);
-    expect((await firstValueFrom(folderService.folderViews$)).length).toBe(0);
-  });
-
-  it("locking should clear", async () => {
-    activeAccountUnlocked.next(false);
-    // Sleep for 100ms to avoid timing issues
-    await new Promise((r) => setTimeout(r, 100));
-
-    expect((await firstValueFrom(folderService.folders$)).length).toBe(0);
-    expect((await firstValueFrom(folderService.folderViews$)).length).toBe(0);
-  });
-
-  describe("clear", () => {
-    it("null userId", async () => {
-      await folderService.clear();
-
-      stateService.received(1).setEncryptedFolders(Arg.any(), Arg.any());
-
-      expect((await firstValueFrom(folderService.folders$)).length).toBe(0);
-      expect((await firstValueFrom(folderService.folderViews$)).length).toBe(0);
-    });
-
-    it("matching userId", async () => {
-      stateService.getUserId().resolves("1");
-      await folderService.clear("1");
-
-      stateService.received(1).setEncryptedFolders(Arg.any(), Arg.any());
-
-      expect((await firstValueFrom(folderService.folders$)).length).toBe(0);
-      expect((await firstValueFrom(folderService.folderViews$)).length).toBe(0);
-    });
-
-    it("missmatching userId", async () => {
-      await folderService.clear("12");
-
-      stateService.received(1).setEncryptedFolders(Arg.any(), Arg.any());
-
-      expect((await firstValueFrom(folderService.folders$)).length).toBe(1);
-      expect((await firstValueFrom(folderService.folderViews$)).length).toBe(2);
-    });
-  });
-
-  function folderData(id: string, name: string) {
-    const data = new FolderData({} as any);
-    data.id = id;
-    data.name = name;
-
-    return data;
-  }
-});

libs/common/spec/services/import.service.spec.ts

@@ -1,16 +1,16 @@
 // eslint-disable-next-line no-restricted-imports
 import { Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
 
-import { CipherService } from "@bitwarden/common/abstractions/cipher.service";
 import { CollectionService } from "@bitwarden/common/abstractions/collection.service";
 import { CryptoService } from "@bitwarden/common/abstractions/crypto.service";
-import { FolderService } from "@bitwarden/common/abstractions/folder/folder.service.abstraction";
 import { I18nService } from "@bitwarden/common/abstractions/i18n.service";
 import { ImportApiServiceAbstraction } from "@bitwarden/common/abstractions/import/import-api.service.abstraction";
 import { BitwardenPasswordProtectedImporter } from "@bitwarden/common/importers/bitwarden-password-protected-importer";
 import { Importer } from "@bitwarden/common/importers/importer";
 import { Utils } from "@bitwarden/common/misc/utils";
 import { ImportService } from "@bitwarden/common/services/import/import.service";
+import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
+import { FolderService } from "@bitwarden/common/vault/abstractions/folder/folder.service.abstraction";
 
 describe("ImportService", () => {
   let importService: ImportService;