[SG 623] Send Service Refactor (#4327)

* Split out api methods into sendApiService * Move SendService and abstraction * Libs updates * Web updates * CLI updates * Desktop updates * libs send service fixes * browser factory additions * Browser updates * Fix service injection for CLI SendReceiveCommand * Deprecate directly calling send state service methods * SendService observables updates * Update components to use new observables * Modify CLI to use state service instead of observables * Remove unnecessary await on get() * Move delete() to InternalSendService * SendService unit tests * Split fileUploadService by send and cipher * send and cipher service factory updates * Add file upload methods to get around circular dependency issues * Move api methods from sendService to sendApiService * Update cipherService to use fileApi methods * libs service injection and component changes * browser service injection and component changes * Desktop component changes * Web component changes * cipher service test fix * Fix file capitalization * CLI service import and command updates * Remove extra abstract fileUploadService * WIP: Condense callbacks for file upload Co-authored-by: Robyn MacCallum <robyntmaccallum@gmail.com> * Send callbacks for file upload * Fix circular service dependencies * Fix response return on upload * Fix function definitions * Service injection fixes and bug fixes * Fix folder casing * Service injection cleanup * Remove deleted file from capital letters whitelist * Create new SendApiService for popup * Move cipherFileUploadService to vault * Move SendFileUploadService methods into SendApiService * Rename methods to remove 'WithServer' * Properly subscribe to sendViews * Fix Send serialization * Implement fromJSON on sendFile and sendText * [PM-1347] Fix send key serialization (#4989) * Properly serialize key on send fromJSON * Remove call that nulled out decrypted sends * Fix null checks in fromJSON methods for models * lint fixes --------- Co-authored-by: Matt Gibson <mgibson@bitwarden.com>
2025-12-10 13:23:34 +00:00 · 2023-03-28 12:37:40 -04:00
parent c2bfb2497b
commit d799529428
58 changed files with 1333 additions and 663 deletions
--- a/libs/common/spec/services/send.service.spec.ts
+++ b/libs/common/spec/services/send.service.spec.ts
@@ -0,0 +1,178 @@
+import { any, mock, MockProxy } from "jest-mock-extended";
+import { BehaviorSubject, firstValueFrom } from "rxjs";
+
+import { CryptoService } from "@bitwarden/common/abstractions/crypto.service";
+import { CryptoFunctionService } from "@bitwarden/common/abstractions/cryptoFunction.service";
+import { EncryptService } from "@bitwarden/common/abstractions/encrypt.service";
+import { I18nService } from "@bitwarden/common/abstractions/i18n.service";
+import { StateService } from "@bitwarden/common/abstractions/state.service";
+import { SendData } from "@bitwarden/common/models/data/send.data";
+import { EncString } from "@bitwarden/common/models/domain/enc-string";
+import { Send } from "@bitwarden/common/models/domain/send";
+import { SendView } from "@bitwarden/common/models/view/send.view";
+import { ContainerService } from "@bitwarden/common/services/container.service";
+import { SendService } from "@bitwarden/common/services/send/send.service";
+
+describe("SendService", () => {
+  const cryptoService = mock<CryptoService>();
+  const i18nService = mock<I18nService>();
+  const cryptoFunctionService = mock<CryptoFunctionService>();
+  const encryptService = mock<EncryptService>();
+
+  let sendService: SendService;
+
+  let stateService: MockProxy<StateService>;
+  let activeAccount: BehaviorSubject<string>;
+  let activeAccountUnlocked: BehaviorSubject<boolean>;
+
+  beforeEach(() => {
+    activeAccount = new BehaviorSubject("123");
+    activeAccountUnlocked = new BehaviorSubject(true);
+
+    stateService = mock<StateService>();
+    stateService.activeAccount$ = activeAccount;
+    stateService.activeAccountUnlocked$ = activeAccountUnlocked;
+    (window as any).bitwardenContainerService = new ContainerService(cryptoService, encryptService);
+
+    stateService.getEncryptedSends.calledWith(any()).mockResolvedValue({
+      "1": sendData("1", "Test Send"),
+    });
+
+    stateService.getDecryptedSends
+      .calledWith(any())
+      .mockResolvedValue([sendView("1", "Test Send")]);
+
+    sendService = new SendService(cryptoService, i18nService, cryptoFunctionService, stateService);
+  });
+
+  afterEach(() => {
+    activeAccount.complete();
+    activeAccountUnlocked.complete();
+  });
+
+  describe("get", () => {
+    it("exists", async () => {
+      const result = sendService.get("1");
+
+      expect(result).toEqual(send("1", "Test Send"));
+    });
+
+    it("does not exist", async () => {
+      const result = sendService.get("2");
+
+      expect(result).toBe(undefined);
+    });
+  });
+
+  it("getAll", async () => {
+    const sends = await sendService.getAll();
+    const send1 = sends[0];
+
+    expect(sends).toHaveLength(1);
+    expect(send1).toEqual(send("1", "Test Send"));
+  });
+
+  describe("getFromState", () => {
+    it("exists", async () => {
+      const result = await sendService.getFromState("1");
+
+      expect(result).toEqual(send("1", "Test Send"));
+    });
+    it("does not exist", async () => {
+      const result = await sendService.getFromState("2");
+
+      expect(result).toBe(null);
+    });
+  });
+
+  it("getAllDecryptedFromState", async () => {
+    await sendService.getAllDecryptedFromState();
+
+    expect(stateService.getDecryptedSends).toHaveBeenCalledTimes(1);
+  });
+
+  // InternalSendService
+
+  it("upsert", async () => {
+    await sendService.upsert(sendData("2", "Test 2"));
+
+    expect(await firstValueFrom(sendService.sends$)).toEqual([
+      send("1", "Test Send"),
+      send("2", "Test 2"),
+    ]);
+  });
+
+  it("replace", async () => {
+    await sendService.replace({ "2": sendData("2", "test 2") });
+
+    expect(await firstValueFrom(sendService.sends$)).toEqual([send("2", "test 2")]);
+  });
+
+  it("clear", async () => {
+    await sendService.clear();
+
+    expect(await firstValueFrom(sendService.sends$)).toEqual([]);
+  });
+
+  describe("delete", () => {
+    it("exists", async () => {
+      await sendService.delete("1");
+
+      expect(stateService.getEncryptedSends).toHaveBeenCalledTimes(2);
+      expect(stateService.setEncryptedSends).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not exist", async () => {
+      sendService.delete("1");
+
+      expect(stateService.getEncryptedSends).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  // Send object helper functions
+
+  function sendData(id: string, name: string) {
+    const data = new SendData({} as any);
+    data.id = id;
+    data.name = name;
+    data.disabled = false;
+    data.accessCount = 2;
+    data.accessId = "1";
+    data.revisionDate = null;
+    data.expirationDate = null;
+    data.deletionDate = null;
+    data.notes = "Notes!!";
+    data.key = null;
+    return data;
+  }
+
+  function sendView(id: string, name: string) {
+    const data = new SendView({} as any);
+    data.id = id;
+    data.name = name;
+    data.disabled = false;
+    data.accessCount = 2;
+    data.accessId = "1";
+    data.revisionDate = null;
+    data.expirationDate = null;
+    data.deletionDate = null;
+    data.notes = "Notes!!";
+    data.key = null;
+    return data;
+  }
+
+  function send(id: string, name: string) {
+    const data = new Send({} as any);
+    data.id = id;
+    data.name = new EncString(name);
+    data.disabled = false;
+    data.accessCount = 2;
+    data.accessId = "1";
+    data.revisionDate = null;
+    data.expirationDate = null;
+    data.deletionDate = null;
+    data.notes = new EncString("Notes!!");
+    data.key = null;
+    return data;
+  }
+});
--- a/libs/common/src/abstractions/api.service.ts
+++ b/libs/common/src/abstractions/api.service.ts
@@ -112,8 +112,6 @@ import { KeysRequest } from "../models/request/keys.request";
 import { OrganizationImportRequest } from "../models/request/organization-import.request";
 import { PreloginRequest } from "../models/request/prelogin.request";
 import { RegisterRequest } from "../models/request/register.request";
-import { SendAccessRequest } from "../models/request/send-access.request";
-import { SendRequest } from "../models/request/send.request";
 import { StorageRequest } from "../models/request/storage.request";
 import { UpdateAvatarRequest } from "../models/request/update-avatar.request";
 import { UpdateDomainsRequest } from "../models/request/update-domains.request";
@@ -125,12 +123,7 @@ import { DomainsResponse } from "../models/response/domains.response";
 import { EventResponse } from "../models/response/event.response";
 import { ListResponse } from "../models/response/list.response";
 import { ProfileResponse } from "../models/response/profile.response";
-import { SendAccessResponse } from "../models/response/send-access.response";
-import { SendFileDownloadDataResponse } from "../models/response/send-file-download-data.response";
-import { SendFileUploadDataResponse } from "../models/response/send-file-upload-data.response";
-import { SendResponse } from "../models/response/send.response";
 import { UserKeyResponse } from "../models/response/user-key.response";
-import { SendAccessView } from "../models/view/send-access.view";
 import { AttachmentRequest } from "../vault/models/request/attachment.request";
 import { CipherBulkDeleteRequest } from "../vault/models/request/cipher-bulk-delete.request";
 import { CipherBulkMoveRequest } from "../vault/models/request/cipher-bulk-move.request";
@@ -213,31 +206,6 @@ export abstract class ApiService {
  getUserBillingHistory: () => Promise<BillingHistoryResponse>;
  getUserBillingPayment: () => Promise<BillingPaymentResponse>;

-  getSend: (id: string) => Promise<SendResponse>;
-  postSendAccess: (
-    id: string,
-    request: SendAccessRequest,
-    apiUrl?: string
-  ) => Promise<SendAccessResponse>;
-  getSends: () => Promise<ListResponse<SendResponse>>;
-  postSend: (request: SendRequest) => Promise<SendResponse>;
-  postFileTypeSend: (request: SendRequest) => Promise<SendFileUploadDataResponse>;
-  postSendFile: (sendId: string, fileId: string, data: FormData) => Promise<any>;
-  /**
-   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
-   * This method still exists for backward compatibility with old server versions.
-   */
-  postSendFileLegacy: (data: FormData) => Promise<SendResponse>;
-  putSend: (id: string, request: SendRequest) => Promise<SendResponse>;
-  putSendRemovePassword: (id: string) => Promise<SendResponse>;
-  deleteSend: (id: string) => Promise<any>;
-  getSendFileDownloadData: (
-    send: SendAccessView,
-    request: SendAccessRequest,
-    apiUrl?: string
-  ) => Promise<SendFileDownloadDataResponse>;
-  renewSendFileUploadUrl: (sendId: string, fileId: string) => Promise<SendFileUploadDataResponse>;
-
  getCipher: (id: string) => Promise<CipherResponse>;
  getFullCipherDetails: (id: string) => Promise<CipherResponse>;
  getCipherAdmin: (id: string) => Promise<CipherResponse>;
--- a/libs/common/src/abstractions/file-upload/file-upload.service.ts
+++ b/libs/common/src/abstractions/file-upload/file-upload.service.ts
@@ -0,0 +1,18 @@
+import { FileUploadType } from "../../enums/fileUploadType";
+import { EncArrayBuffer } from "../../models/domain/enc-array-buffer";
+import { EncString } from "../../models/domain/enc-string";
+
+export abstract class FileUploadService {
+  upload: (
+    uploadData: { url: string; fileUploadType: FileUploadType },
+    fileName: EncString,
+    encryptedFileData: EncArrayBuffer,
+    fileUploadMethods: FileUploadApiMethods
+  ) => Promise<void>;
+}
+
+export type FileUploadApiMethods = {
+  postDirect: (fileData: FormData) => Promise<void>;
+  renewFileUploadUrl: () => Promise<string>;
+  rollback: () => Promise<void>;
+};
--- a/libs/common/src/abstractions/fileUpload.service.ts
+++ b/libs/common/src/abstractions/fileUpload.service.ts
@@ -1,18 +0,0 @@
-import { EncArrayBuffer } from "../models/domain/enc-array-buffer";
-import { EncString } from "../models/domain/enc-string";
-import { SendFileUploadDataResponse } from "../models/response/send-file-upload-data.response";
-import { AttachmentUploadDataResponse } from "../vault/models/response/attachment-upload-data.response";
-
-export abstract class FileUploadService {
-  uploadSendFile: (
-    uploadData: SendFileUploadDataResponse,
-    fileName: EncString,
-    encryptedFileData: EncArrayBuffer
-  ) => Promise<any>;
-  uploadCipherAttachment: (
-    admin: boolean,
-    uploadData: AttachmentUploadDataResponse,
-    fileName: EncString,
-    encryptedFileData: EncArrayBuffer
-  ) => Promise<any>;
-}
--- a/libs/common/src/abstractions/send.service.ts
+++ b/libs/common/src/abstractions/send.service.ts
@@ -1,25 +0,0 @@
-import { SendData } from "../models/data/send.data";
-import { EncArrayBuffer } from "../models/domain/enc-array-buffer";
-import { Send } from "../models/domain/send";
-import { SymmetricCryptoKey } from "../models/domain/symmetric-crypto-key";
-import { SendView } from "../models/view/send.view";
-
-export abstract class SendService {
-  clearCache: () => Promise<void>;
-  encrypt: (
-    model: SendView,
-    file: File | ArrayBuffer,
-    password: string,
-    key?: SymmetricCryptoKey
-  ) => Promise<[Send, EncArrayBuffer]>;
-  get: (id: string) => Promise<Send>;
-  getAll: () => Promise<Send[]>;
-  getAllDecrypted: () => Promise<SendView[]>;
-  saveWithServer: (sendData: [Send, EncArrayBuffer]) => Promise<any>;
-  upsert: (send: SendData | SendData[]) => Promise<any>;
-  replace: (sends: { [id: string]: SendData }) => Promise<any>;
-  clear: (userId: string) => Promise<any>;
-  delete: (id: string | string[]) => Promise<any>;
-  deleteWithServer: (id: string) => Promise<any>;
-  removePasswordWithServer: (id: string) => Promise<any>;
-}
--- a/libs/common/src/abstractions/send/send-api.service.abstraction.ts
+++ b/libs/common/src/abstractions/send/send-api.service.abstraction.ts
@@ -0,0 +1,40 @@
+import { EncArrayBuffer } from "../../models/domain/enc-array-buffer";
+import { Send } from "../../models/domain/send";
+import { SendAccessRequest } from "../../models/request/send-access.request";
+import { SendRequest } from "../../models/request/send.request";
+import { ListResponse } from "../../models/response/list.response";
+import { SendAccessResponse } from "../../models/response/send-access.response";
+import { SendFileDownloadDataResponse } from "../../models/response/send-file-download-data.response";
+import { SendFileUploadDataResponse } from "../../models/response/send-file-upload-data.response";
+import { SendResponse } from "../../models/response/send.response";
+import { SendAccessView } from "../../models/view/send-access.view";
+
+export abstract class SendApiService {
+  getSend: (id: string) => Promise<SendResponse>;
+  postSendAccess: (
+    id: string,
+    request: SendAccessRequest,
+    apiUrl?: string
+  ) => Promise<SendAccessResponse>;
+  getSends: () => Promise<ListResponse<SendResponse>>;
+  postSend: (request: SendRequest) => Promise<SendResponse>;
+  postFileTypeSend: (request: SendRequest) => Promise<SendFileUploadDataResponse>;
+  postSendFile: (sendId: string, fileId: string, data: FormData) => Promise<any>;
+  /**
+   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
+   * This method still exists for backward compatibility with old server versions.
+   */
+  postSendFileLegacy: (data: FormData) => Promise<SendResponse>;
+  putSend: (id: string, request: SendRequest) => Promise<SendResponse>;
+  putSendRemovePassword: (id: string) => Promise<SendResponse>;
+  deleteSend: (id: string) => Promise<any>;
+  getSendFileDownloadData: (
+    send: SendAccessView,
+    request: SendAccessRequest,
+    apiUrl?: string
+  ) => Promise<SendFileDownloadDataResponse>;
+  renewSendFileUploadUrl: (sendId: string, fileId: string) => Promise<SendFileUploadDataResponse>;
+  removePassword: (id: string) => Promise<any>;
+  delete: (id: string) => Promise<any>;
+  save: (sendData: [Send, EncArrayBuffer]) => Promise<any>;
+}
--- a/libs/common/src/abstractions/send/send.service.abstraction.ts
+++ b/libs/common/src/abstractions/send/send.service.abstraction.ts
@@ -0,0 +1,39 @@
+import { Observable } from "rxjs";
+
+import { SendData } from "../../models/data/send.data";
+import { EncArrayBuffer } from "../../models/domain/enc-array-buffer";
+import { Send } from "../../models/domain/send";
+import { SymmetricCryptoKey } from "../../models/domain/symmetric-crypto-key";
+import { SendView } from "../../models/view/send.view";
+
+export abstract class SendService {
+  sends$: Observable<Send[]>;
+  sendViews$: Observable<SendView[]>;
+
+  encrypt: (
+    model: SendView,
+    file: File | ArrayBuffer,
+    password: string,
+    key?: SymmetricCryptoKey
+  ) => Promise<[Send, EncArrayBuffer]>;
+  get: (id: string) => Send;
+  /**
+   * @deprecated Do not call this, use the sends$ observable collection
+   */
+  getAll: () => Promise<Send[]>;
+  /**
+   * @deprecated Only use in CLI
+   */
+  getFromState: (id: string) => Promise<Send>;
+  /**
+   * @deprecated Only use in CLI
+   */
+  getAllDecryptedFromState: () => Promise<SendView[]>;
+}
+
+export abstract class InternalSendService extends SendService {
+  upsert: (send: SendData | SendData[]) => Promise<any>;
+  replace: (sends: { [id: string]: SendData }) => Promise<void>;
+  clear: (userId: string) => Promise<any>;
+  delete: (id: string | string[]) => Promise<any>;
+}
--- a/libs/common/src/abstractions/state.service.ts
+++ b/libs/common/src/abstractions/state.service.ts
@@ -120,7 +120,13 @@ export abstract class StateService<T extends Account = Account> {
    value: Map<string, SymmetricCryptoKey>,
    options?: StorageOptions
  ) => Promise<void>;
+  /**
+   * @deprecated Do not call this directly, use SendService
+   */
  getDecryptedSends: (options?: StorageOptions) => Promise<SendView[]>;
+  /**
+   * @deprecated Do not call this directly, use SendService
+   */
  setDecryptedSends: (value: SendView[], options?: StorageOptions) => Promise<void>;
  getDefaultUriMatch: (options?: StorageOptions) => Promise<UriMatchType>;
  setDefaultUriMatch: (value: UriMatchType, options?: StorageOptions) => Promise<void>;
@@ -237,7 +243,13 @@ export abstract class StateService<T extends Account = Account> {
  setEncryptedPrivateKey: (value: string, options?: StorageOptions) => Promise<void>;
  getEncryptedProviderKeys: (options?: StorageOptions) => Promise<any>;
  setEncryptedProviderKeys: (value: any, options?: StorageOptions) => Promise<void>;
+  /**
+   * @deprecated Do not call this directly, use SendService
+   */
  getEncryptedSends: (options?: StorageOptions) => Promise<{ [id: string]: SendData }>;
+  /**
+   * @deprecated Do not call this directly, use SendService
+   */
  setEncryptedSends: (value: { [id: string]: SendData }, options?: StorageOptions) => Promise<void>;
  getEntityId: (options?: StorageOptions) => Promise<string>;
  setEntityId: (value: string, options?: StorageOptions) => Promise<void>;
--- a/libs/common/src/models/domain/send-file.ts
+++ b/libs/common/src/models/domain/send-file.ts
@@ -1,3 +1,5 @@
+import { Jsonify } from "type-fest";
+
 import { SendFileData } from "../data/send-file.data";
 import { SendFileView } from "../view/send-file.view";

@@ -41,4 +43,14 @@ export class SendFile extends Domain {
    );
    return view;
  }
+
+  static fromJSON(obj: Jsonify<SendFile>) {
+    if (obj == null) {
+      return null;
+    }
+
+    return Object.assign(new SendFile(), obj, {
+      fileName: EncString.fromJSON(obj.fileName),
+    });
+  }
 }
--- a/libs/common/src/models/domain/send-text.ts
+++ b/libs/common/src/models/domain/send-text.ts
@@ -1,3 +1,5 @@
+import { Jsonify } from "type-fest";
+
 import { SendTextData } from "../data/send-text.data";
 import { SendTextView } from "../view/send-text.view";

@@ -36,4 +38,14 @@ export class SendText extends Domain {
      key
    );
  }
+
+  static fromJSON(obj: Jsonify<SendText>) {
+    if (obj == null) {
+      return null;
+    }
+
+    return Object.assign(new SendText(), obj, {
+      text: EncString.fromJSON(obj.text),
+    });
+  }
 }
--- a/libs/common/src/models/domain/send.ts
+++ b/libs/common/src/models/domain/send.ts
@@ -1,3 +1,5 @@
+import { Jsonify } from "type-fest";
+
 import { SendType } from "../../enums/sendType";
 import { Utils } from "../../misc/utils";
 import { SendData } from "../data/send.data";
@@ -102,4 +104,25 @@ export class Send extends Domain {

    return model;
  }
+
+  static fromJSON(obj: Jsonify<Send>) {
+    if (obj == null) {
+      return null;
+    }
+
+    const revisionDate = obj.revisionDate == null ? null : new Date(obj.revisionDate);
+    const expirationDate = obj.expirationDate == null ? null : new Date(obj.expirationDate);
+    const deletionDate = obj.deletionDate == null ? null : new Date(obj.deletionDate);
+
+    return Object.assign(new Send(), obj, {
+      key: EncString.fromJSON(obj.key),
+      name: EncString.fromJSON(obj.name),
+      notes: EncString.fromJSON(obj.notes),
+      text: SendText.fromJSON(obj.text),
+      file: SendFile.fromJSON(obj.file),
+      revisionDate,
+      expirationDate,
+      deletionDate,
+    });
+  }
 }
--- a/libs/common/src/services/api.service.ts
+++ b/libs/common/src/services/api.service.ts
@@ -121,8 +121,6 @@ import { KeysRequest } from "../models/request/keys.request";
 import { OrganizationImportRequest } from "../models/request/organization-import.request";
 import { PreloginRequest } from "../models/request/prelogin.request";
 import { RegisterRequest } from "../models/request/register.request";
-import { SendAccessRequest } from "../models/request/send-access.request";
-import { SendRequest } from "../models/request/send.request";
 import { StorageRequest } from "../models/request/storage.request";
 import { UpdateAvatarRequest } from "../models/request/update-avatar.request";
 import { UpdateDomainsRequest } from "../models/request/update-domains.request";
@@ -135,12 +133,7 @@ import { ErrorResponse } from "../models/response/error.response";
 import { EventResponse } from "../models/response/event.response";
 import { ListResponse } from "../models/response/list.response";
 import { ProfileResponse } from "../models/response/profile.response";
-import { SendAccessResponse } from "../models/response/send-access.response";
-import { SendFileDownloadDataResponse } from "../models/response/send-file-download-data.response";
-import { SendFileUploadDataResponse } from "../models/response/send-file-upload-data.response";
-import { SendResponse } from "../models/response/send.response";
 import { UserKeyResponse } from "../models/response/user-key.response";
-import { SendAccessView } from "../models/view/send-access.view";
 import { AttachmentRequest } from "../vault/models/request/attachment.request";
 import { CipherBulkDeleteRequest } from "../vault/models/request/cipher-bulk-delete.request";
 import { CipherBulkMoveRequest } from "../vault/models/request/cipher-bulk-move.request";
@@ -485,103 +478,6 @@ export class ApiService implements ApiServiceAbstraction {
    return new BillingPaymentResponse(r);
  }

-  // Send APIs
-
-  async getSend(id: string): Promise<SendResponse> {
-    const r = await this.send("GET", "/sends/" + id, null, true, true);
-    return new SendResponse(r);
-  }
-
-  async postSendAccess(
-    id: string,
-    request: SendAccessRequest,
-    apiUrl?: string
-  ): Promise<SendAccessResponse> {
-    const addSendIdHeader = (headers: Headers) => {
-      headers.set("Send-Id", id);
-    };
-    const r = await this.send(
-      "POST",
-      "/sends/access/" + id,
-      request,
-      false,
-      true,
-      apiUrl,
-      addSendIdHeader
-    );
-    return new SendAccessResponse(r);
-  }
-
-  async getSendFileDownloadData(
-    send: SendAccessView,
-    request: SendAccessRequest,
-    apiUrl?: string
-  ): Promise<SendFileDownloadDataResponse> {
-    const addSendIdHeader = (headers: Headers) => {
-      headers.set("Send-Id", send.id);
-    };
-    const r = await this.send(
-      "POST",
-      "/sends/" + send.id + "/access/file/" + send.file.id,
-      request,
-      false,
-      true,
-      apiUrl,
-      addSendIdHeader
-    );
-    return new SendFileDownloadDataResponse(r);
-  }
-
-  async getSends(): Promise<ListResponse<SendResponse>> {
-    const r = await this.send("GET", "/sends", null, true, true);
-    return new ListResponse(r, SendResponse);
-  }
-
-  async postSend(request: SendRequest): Promise<SendResponse> {
-    const r = await this.send("POST", "/sends", request, true, true);
-    return new SendResponse(r);
-  }
-
-  async postFileTypeSend(request: SendRequest): Promise<SendFileUploadDataResponse> {
-    const r = await this.send("POST", "/sends/file/v2", request, true, true);
-    return new SendFileUploadDataResponse(r);
-  }
-
-  async renewSendFileUploadUrl(
-    sendId: string,
-    fileId: string
-  ): Promise<SendFileUploadDataResponse> {
-    const r = await this.send("GET", "/sends/" + sendId + "/file/" + fileId, null, true, true);
-    return new SendFileUploadDataResponse(r);
-  }
-
-  postSendFile(sendId: string, fileId: string, data: FormData): Promise<any> {
-    return this.send("POST", "/sends/" + sendId + "/file/" + fileId, data, true, false);
-  }
-
-  /**
-   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
-   * This method still exists for backward compatibility with old server versions.
-   */
-  async postSendFileLegacy(data: FormData): Promise<SendResponse> {
-    const r = await this.send("POST", "/sends/file", data, true, true);
-    return new SendResponse(r);
-  }
-
-  async putSend(id: string, request: SendRequest): Promise<SendResponse> {
-    const r = await this.send("PUT", "/sends/" + id, request, true, true);
-    return new SendResponse(r);
-  }
-
-  async putSendRemovePassword(id: string): Promise<SendResponse> {
-    const r = await this.send("PUT", "/sends/" + id + "/remove-password", null, true, true);
-    return new SendResponse(r);
-  }
-
-  deleteSend(id: string): Promise<any> {
-    return this.send("DELETE", "/sends/" + id, null, true, false);
-  }
-
  // Cipher APIs

  async getCipher(id: string): Promise<CipherResponse> {
--- a/libs/common/src/services/file-upload/file-upload.service.ts
+++ b/libs/common/src/services/file-upload/file-upload.service.ts
@@ -0,0 +1,52 @@
+import {
+  FileUploadApiMethods,
+  FileUploadService as FileUploadServiceAbstraction,
+} from "../../abstractions/file-upload/file-upload.service";
+import { LogService } from "../../abstractions/log.service";
+import { FileUploadType } from "../../enums/fileUploadType";
+import { EncArrayBuffer } from "../../models/domain/enc-array-buffer";
+import { EncString } from "../../models/domain/enc-string";
+import { AzureFileUploadService } from "../azureFileUpload.service";
+import { BitwardenFileUploadService } from "../bitwardenFileUpload.service";
+
+export class FileUploadService implements FileUploadServiceAbstraction {
+  private azureFileUploadService: AzureFileUploadService;
+  private bitwardenFileUploadService: BitwardenFileUploadService;
+
+  constructor(protected logService: LogService) {
+    this.azureFileUploadService = new AzureFileUploadService(logService);
+    this.bitwardenFileUploadService = new BitwardenFileUploadService();
+  }
+
+  async upload(
+    uploadData: { url: string; fileUploadType: FileUploadType },
+    fileName: EncString,
+    encryptedFileData: EncArrayBuffer,
+    fileUploadMethods: FileUploadApiMethods
+  ) {
+    try {
+      switch (uploadData.fileUploadType) {
+        case FileUploadType.Direct:
+          await this.bitwardenFileUploadService.upload(
+            fileName.encryptedString,
+            encryptedFileData,
+            (fd) => fileUploadMethods.postDirect(fd)
+          );
+          break;
+        case FileUploadType.Azure: {
+          await this.azureFileUploadService.upload(
+            uploadData.url,
+            encryptedFileData,
+            fileUploadMethods.renewFileUploadUrl
+          );
+          break;
+        }
+        default:
+          throw new Error("Unknown file upload type");
+      }
+    } catch (e) {
+      await fileUploadMethods.rollback();
+      throw e;
+    }
+  }
+}
--- a/libs/common/src/services/fileUpload.service.ts
+++ b/libs/common/src/services/fileUpload.service.ts
@@ -1,108 +0,0 @@
-import { ApiService } from "../abstractions/api.service";
-import { FileUploadService as FileUploadServiceAbstraction } from "../abstractions/fileUpload.service";
-import { LogService } from "../abstractions/log.service";
-import { FileUploadType } from "../enums/fileUploadType";
-import { EncArrayBuffer } from "../models/domain/enc-array-buffer";
-import { EncString } from "../models/domain/enc-string";
-import { SendFileUploadDataResponse } from "../models/response/send-file-upload-data.response";
-import { AttachmentUploadDataResponse } from "../vault/models/response/attachment-upload-data.response";
-
-import { AzureFileUploadService } from "./azureFileUpload.service";
-import { BitwardenFileUploadService } from "./bitwardenFileUpload.service";
-
-export class FileUploadService implements FileUploadServiceAbstraction {
-  private azureFileUploadService: AzureFileUploadService;
-  private bitwardenFileUploadService: BitwardenFileUploadService;
-
-  constructor(private logService: LogService, private apiService: ApiService) {
-    this.azureFileUploadService = new AzureFileUploadService(logService);
-    this.bitwardenFileUploadService = new BitwardenFileUploadService();
-  }
-
-  async uploadSendFile(
-    uploadData: SendFileUploadDataResponse,
-    fileName: EncString,
-    encryptedFileData: EncArrayBuffer
-  ) {
-    try {
-      switch (uploadData.fileUploadType) {
-        case FileUploadType.Direct:
-          await this.bitwardenFileUploadService.upload(
-            fileName.encryptedString,
-            encryptedFileData,
-            (fd) =>
-              this.apiService.postSendFile(
-                uploadData.sendResponse.id,
-                uploadData.sendResponse.file.id,
-                fd
-              )
-          );
-          break;
-        case FileUploadType.Azure: {
-          const renewalCallback = async () => {
-            const renewalResponse = await this.apiService.renewSendFileUploadUrl(
-              uploadData.sendResponse.id,
-              uploadData.sendResponse.file.id
-            );
-            return renewalResponse.url;
-          };
-          await this.azureFileUploadService.upload(
-            uploadData.url,
-            encryptedFileData,
-            renewalCallback
-          );
-          break;
-        }
-        default:
-          throw new Error("Unknown file upload type");
-      }
-    } catch (e) {
-      await this.apiService.deleteSend(uploadData.sendResponse.id);
-      throw e;
-    }
-  }
-
-  async uploadCipherAttachment(
-    admin: boolean,
-    uploadData: AttachmentUploadDataResponse,
-    encryptedFileName: EncString,
-    encryptedFileData: EncArrayBuffer
-  ) {
-    const response = admin ? uploadData.cipherMiniResponse : uploadData.cipherResponse;
-    try {
-      switch (uploadData.fileUploadType) {
-        case FileUploadType.Direct:
-          await this.bitwardenFileUploadService.upload(
-            encryptedFileName.encryptedString,
-            encryptedFileData,
-            (fd) => this.apiService.postAttachmentFile(response.id, uploadData.attachmentId, fd)
-          );
-          break;
-        case FileUploadType.Azure: {
-          const renewalCallback = async () => {
-            const renewalResponse = await this.apiService.renewAttachmentUploadUrl(
-              response.id,
-              uploadData.attachmentId
-            );
-            return renewalResponse.url;
-          };
-          await this.azureFileUploadService.upload(
-            uploadData.url,
-            encryptedFileData,
-            renewalCallback
-          );
-          break;
-        }
-        default:
-          throw new Error("Unknown file upload type.");
-      }
-    } catch (e) {
-      if (admin) {
-        await this.apiService.deleteCipherAttachmentAdmin(response.id, uploadData.attachmentId);
-      } else {
-        await this.apiService.deleteCipherAttachment(response.id, uploadData.attachmentId);
-      }
-      throw e;
-    }
-  }
-}
--- a/libs/common/src/services/send/send-api.service.ts
+++ b/libs/common/src/services/send/send-api.service.ts
@@ -0,0 +1,251 @@
+import { SendType } from "../../../../common/src/enums/sendType";
+import { Utils } from "../../../../common/src/misc/utils";
+import { ErrorResponse } from "../../../../common/src/models/response/error.response";
+import { ApiService } from "../../abstractions/api.service";
+import {
+  FileUploadApiMethods,
+  FileUploadService,
+} from "../../abstractions/file-upload/file-upload.service";
+import { SendApiService as SendApiServiceAbstraction } from "../../abstractions/send/send-api.service.abstraction";
+import { InternalSendService } from "../../abstractions/send/send.service.abstraction";
+import { SendData } from "../../models/data/send.data";
+import { EncArrayBuffer } from "../../models/domain/enc-array-buffer";
+import { Send } from "../../models/domain/send";
+import { SendAccessRequest } from "../../models/request/send-access.request";
+import { SendRequest } from "../../models/request/send.request";
+import { ListResponse } from "../../models/response/list.response";
+import { SendAccessResponse } from "../../models/response/send-access.response";
+import { SendFileDownloadDataResponse } from "../../models/response/send-file-download-data.response";
+import { SendFileUploadDataResponse } from "../../models/response/send-file-upload-data.response";
+import { SendResponse } from "../../models/response/send.response";
+import { SendAccessView } from "../../models/view/send-access.view";
+
+export class SendApiService implements SendApiServiceAbstraction {
+  constructor(
+    private apiService: ApiService,
+    private fileUploadService: FileUploadService,
+    private sendService: InternalSendService
+  ) {}
+
+  async getSend(id: string): Promise<SendResponse> {
+    const r = await this.apiService.send("GET", "/sends/" + id, null, true, true);
+    return new SendResponse(r);
+  }
+
+  async postSendAccess(
+    id: string,
+    request: SendAccessRequest,
+    apiUrl?: string
+  ): Promise<SendAccessResponse> {
+    const addSendIdHeader = (headers: Headers) => {
+      headers.set("Send-Id", id);
+    };
+    const r = await this.apiService.send(
+      "POST",
+      "/sends/access/" + id,
+      request,
+      false,
+      true,
+      apiUrl,
+      addSendIdHeader
+    );
+    return new SendAccessResponse(r);
+  }
+
+  async getSendFileDownloadData(
+    send: SendAccessView,
+    request: SendAccessRequest,
+    apiUrl?: string
+  ): Promise<SendFileDownloadDataResponse> {
+    const addSendIdHeader = (headers: Headers) => {
+      headers.set("Send-Id", send.id);
+    };
+    const r = await this.apiService.send(
+      "POST",
+      "/sends/" + send.id + "/access/file/" + send.file.id,
+      request,
+      false,
+      true,
+      apiUrl,
+      addSendIdHeader
+    );
+    return new SendFileDownloadDataResponse(r);
+  }
+
+  async getSends(): Promise<ListResponse<SendResponse>> {
+    const r = await this.apiService.send("GET", "/sends", null, true, true);
+    return new ListResponse(r, SendResponse);
+  }
+
+  async postSend(request: SendRequest): Promise<SendResponse> {
+    const r = await this.apiService.send("POST", "/sends", request, true, true);
+    return new SendResponse(r);
+  }
+
+  async postFileTypeSend(request: SendRequest): Promise<SendFileUploadDataResponse> {
+    const r = await this.apiService.send("POST", "/sends/file/v2", request, true, true);
+    return new SendFileUploadDataResponse(r);
+  }
+
+  async renewSendFileUploadUrl(
+    sendId: string,
+    fileId: string
+  ): Promise<SendFileUploadDataResponse> {
+    const r = await this.apiService.send(
+      "GET",
+      "/sends/" + sendId + "/file/" + fileId,
+      null,
+      true,
+      true
+    );
+    return new SendFileUploadDataResponse(r);
+  }
+
+  postSendFile(sendId: string, fileId: string, data: FormData): Promise<any> {
+    return this.apiService.send("POST", "/sends/" + sendId + "/file/" + fileId, data, true, false);
+  }
+
+  /**
+   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
+   * This method still exists for backward compatibility with old server versions.
+   */
+  async postSendFileLegacy(data: FormData): Promise<SendResponse> {
+    const r = await this.apiService.send("POST", "/sends/file", data, true, true);
+    return new SendResponse(r);
+  }
+
+  async putSend(id: string, request: SendRequest): Promise<SendResponse> {
+    const r = await this.apiService.send("PUT", "/sends/" + id, request, true, true);
+    return new SendResponse(r);
+  }
+
+  async putSendRemovePassword(id: string): Promise<SendResponse> {
+    const r = await this.apiService.send(
+      "PUT",
+      "/sends/" + id + "/remove-password",
+      null,
+      true,
+      true
+    );
+    return new SendResponse(r);
+  }
+
+  deleteSend(id: string): Promise<any> {
+    return this.apiService.send("DELETE", "/sends/" + id, null, true, false);
+  }
+
+  async save(sendData: [Send, EncArrayBuffer]): Promise<any> {
+    const response = await this.upload(sendData);
+
+    const data = new SendData(response);
+    await this.sendService.upsert(data);
+  }
+
+  async delete(id: string): Promise<any> {
+    await this.deleteSend(id);
+    await this.sendService.delete(id);
+  }
+
+  async removePassword(id: string): Promise<any> {
+    const response = await this.putSendRemovePassword(id);
+    const data = new SendData(response);
+    await this.sendService.upsert(data);
+  }
+
+  // Send File Upload methoids
+
+  private async upload(sendData: [Send, EncArrayBuffer]): Promise<SendResponse> {
+    const request = new SendRequest(sendData[0], sendData[1]?.buffer.byteLength);
+    let response: SendResponse;
+    if (sendData[0].id == null) {
+      if (sendData[0].type === SendType.Text) {
+        response = await this.postSend(request);
+      } else {
+        try {
+          const uploadDataResponse = await this.postFileTypeSend(request);
+          response = uploadDataResponse.sendResponse;
+          await this.fileUploadService.upload(
+            uploadDataResponse,
+            sendData[0].file.fileName,
+            sendData[1],
+            this.generateMethods(uploadDataResponse, response)
+          );
+        } catch (e) {
+          if (e instanceof ErrorResponse && (e as ErrorResponse).statusCode === 404) {
+            response = await this.legacyServerSendFileUpload(sendData, request);
+          } else if (e instanceof ErrorResponse) {
+            throw new Error((e as ErrorResponse).getSingleMessage());
+          } else {
+            throw e;
+          }
+        }
+      }
+      sendData[0].id = response.id;
+      sendData[0].accessId = response.accessId;
+    } else {
+      response = await this.putSend(sendData[0].id, request);
+    }
+    return response;
+  }
+
+  private generateMethods(
+    uploadData: SendFileUploadDataResponse,
+    response: SendResponse
+  ): FileUploadApiMethods {
+    return {
+      postDirect: this.generatePostDirectCallback(response),
+      renewFileUploadUrl: this.generateRenewFileUploadUrlCallback(response.id, response.file.id),
+      rollback: this.generateRollbackCallback(response.id),
+    };
+  }
+
+  private generatePostDirectCallback(sendResponse: SendResponse) {
+    return (data: FormData) => {
+      return this.postSendFile(sendResponse.id, sendResponse.file.id, data);
+    };
+  }
+
+  private generateRenewFileUploadUrlCallback(sendId: string, fileId: string) {
+    return async () => {
+      const renewResponse = await this.renewSendFileUploadUrl(sendId, fileId);
+      return renewResponse?.url;
+    };
+  }
+
+  private generateRollbackCallback(sendId: string) {
+    return () => {
+      return this.deleteSend(sendId);
+    };
+  }
+
+  /**
+   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
+   * This method still exists for backward compatibility with old server versions.
+   */
+  async legacyServerSendFileUpload(
+    sendData: [Send, EncArrayBuffer],
+    request: SendRequest
+  ): Promise<SendResponse> {
+    const fd = new FormData();
+    try {
+      const blob = new Blob([sendData[1].buffer], { type: "application/octet-stream" });
+      fd.append("model", JSON.stringify(request));
+      fd.append("data", blob, sendData[0].file.fileName.encryptedString);
+    } catch (e) {
+      if (Utils.isNode && !Utils.isBrowser) {
+        fd.append("model", JSON.stringify(request));
+        fd.append(
+          "data",
+          Buffer.from(sendData[1].buffer) as any,
+          {
+            filepath: sendData[0].file.fileName.encryptedString,
+            contentType: "application/octet-stream",
+          } as any
+        );
+      } else {
+        throw e;
+      }
+    }
+    return await this.postSendFileLegacy(fd);
+  }
+}
--- a/libs/common/src/services/send/send.service.ts
+++ b/libs/common/src/services/send/send.service.ts
@@ -1,37 +1,58 @@
-import { ApiService } from "../abstractions/api.service";
-import { CryptoService } from "../abstractions/crypto.service";
-import { CryptoFunctionService } from "../abstractions/cryptoFunction.service";
-import { FileUploadService } from "../abstractions/fileUpload.service";
-import { I18nService } from "../abstractions/i18n.service";
-import { SendService as SendServiceAbstraction } from "../abstractions/send.service";
-import { StateService } from "../abstractions/state.service";
-import { SEND_KDF_ITERATIONS } from "../enums/kdfType";
-import { SendType } from "../enums/sendType";
-import { Utils } from "../misc/utils";
-import { SendData } from "../models/data/send.data";
-import { EncArrayBuffer } from "../models/domain/enc-array-buffer";
-import { EncString } from "../models/domain/enc-string";
-import { Send } from "../models/domain/send";
-import { SendFile } from "../models/domain/send-file";
-import { SendText } from "../models/domain/send-text";
-import { SymmetricCryptoKey } from "../models/domain/symmetric-crypto-key";
-import { SendRequest } from "../models/request/send.request";
-import { ErrorResponse } from "../models/response/error.response";
-import { SendResponse } from "../models/response/send.response";
-import { SendView } from "../models/view/send.view";
+import { BehaviorSubject, concatMap } from "rxjs";
+
+import { CryptoService } from "../../abstractions/crypto.service";
+import { CryptoFunctionService } from "../../abstractions/cryptoFunction.service";
+import { I18nService } from "../../abstractions/i18n.service";
+import { InternalSendService as InternalSendServiceAbstraction } from "../../abstractions/send/send.service.abstraction";
+import { StateService } from "../../abstractions/state.service";
+import { SEND_KDF_ITERATIONS } from "../../enums/kdfType";
+import { SendType } from "../../enums/sendType";
+import { Utils } from "../../misc/utils";
+import { SendData } from "../../models/data/send.data";
+import { EncArrayBuffer } from "../../models/domain/enc-array-buffer";
+import { EncString } from "../../models/domain/enc-string";
+import { Send } from "../../models/domain/send";
+import { SendFile } from "../../models/domain/send-file";
+import { SendText } from "../../models/domain/send-text";
+import { SymmetricCryptoKey } from "../../models/domain/symmetric-crypto-key";
+import { SendView } from "../../models/view/send.view";
+
+export class SendService implements InternalSendServiceAbstraction {
+  protected _sends: BehaviorSubject<Send[]> = new BehaviorSubject([]);
+  protected _sendViews: BehaviorSubject<SendView[]> = new BehaviorSubject([]);
+
+  sends$ = this._sends.asObservable();
+  sendViews$ = this._sendViews.asObservable();

-export class SendService implements SendServiceAbstraction {
  constructor(
    private cryptoService: CryptoService,
-    private apiService: ApiService,
-    private fileUploadService: FileUploadService,
    private i18nService: I18nService,
    private cryptoFunctionService: CryptoFunctionService,
    private stateService: StateService
-  ) {}
+  ) {
+    this.stateService.activeAccountUnlocked$
+      .pipe(
+        concatMap(async (unlocked) => {
+          if (Utils.global.bitwardenContainerService == null) {
+            return;
+          }
+
+          if (!unlocked) {
+            this._sends.next([]);
+            this._sendViews.next([]);
+            return;
+          }
+
+          const data = await this.stateService.getEncryptedSends();
+
+          await this.updateObservables(data);
+        })
+      )
+      .subscribe();
+  }

  async clearCache(): Promise<void> {
-    await this.stateService.setDecryptedSends(null);
+    await this._sendViews.next([]);
  }

  async encrypt(
@@ -87,7 +108,12 @@ export class SendService implements SendServiceAbstraction {
    return [send, fileData];
  }

-  async get(id: string): Promise<Send> {
+  get(id: string): Send {
+    const sends = this._sends.getValue();
+    return sends.find((send) => send.id === id);
+  }
+
+  async getFromState(id: string): Promise<Send> {
    const sends = await this.stateService.getEncryptedSends();
    // eslint-disable-next-line
    if (sends == null || !sends.hasOwnProperty(id)) {
@@ -109,7 +135,7 @@ export class SendService implements SendServiceAbstraction {
    return response;
  }

-  async getAllDecrypted(): Promise<SendView[]> {
+  async getAllDecryptedFromState(): Promise<SendView[]> {
    let decSends = await this.stateService.getDecryptedSends();
    if (decSends != null) {
      return decSends;
@@ -134,79 +160,11 @@ export class SendService implements SendServiceAbstraction {
    return decSends;
  }

-  async saveWithServer(sendData: [Send, EncArrayBuffer]): Promise<any> {
-    const request = new SendRequest(sendData[0], sendData[1]?.buffer.byteLength);
-    let response: SendResponse;
-    if (sendData[0].id == null) {
-      if (sendData[0].type === SendType.Text) {
-        response = await this.apiService.postSend(request);
-      } else {
-        try {
-          const uploadDataResponse = await this.apiService.postFileTypeSend(request);
-          response = uploadDataResponse.sendResponse;
-
-          await this.fileUploadService.uploadSendFile(
-            uploadDataResponse,
-            sendData[0].file.fileName,
-            sendData[1]
-          );
-        } catch (e) {
-          if (e instanceof ErrorResponse && (e as ErrorResponse).statusCode === 404) {
-            response = await this.legacyServerSendFileUpload(sendData, request);
-          } else if (e instanceof ErrorResponse) {
-            throw new Error((e as ErrorResponse).getSingleMessage());
-          } else {
-            throw e;
-          }
-        }
-      }
-      sendData[0].id = response.id;
-      sendData[0].accessId = response.accessId;
-    } else {
-      response = await this.apiService.putSend(sendData[0].id, request);
-    }
-
-    const data = new SendData(response);
-    await this.upsert(data);
-  }
-
-  /**
-   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
-   * This method still exists for backward compatibility with old server versions.
-   */
-  async legacyServerSendFileUpload(
-    sendData: [Send, EncArrayBuffer],
-    request: SendRequest
-  ): Promise<SendResponse> {
-    const fd = new FormData();
-    try {
-      const blob = new Blob([sendData[1].buffer], { type: "application/octet-stream" });
-      fd.append("model", JSON.stringify(request));
-      fd.append("data", blob, sendData[0].file.fileName.encryptedString);
-    } catch (e) {
-      if (Utils.isNode && !Utils.isBrowser) {
-        fd.append("model", JSON.stringify(request));
-        fd.append(
-          "data",
-          Buffer.from(sendData[1].buffer) as any,
-          {
-            filepath: sendData[0].file.fileName.encryptedString,
-            contentType: "application/octet-stream",
-          } as any
-        );
-      } else {
-        throw e;
-      }
-    }
-    return await this.apiService.postSendFileLegacy(fd);
-  }
-
  async upsert(send: SendData | SendData[]): Promise<any> {
    let sends = await this.stateService.getEncryptedSends();
    if (sends == null) {
      sends = {};
    }
-
    if (send instanceof SendData) {
      const s = send as SendData;
      sends[s.id] = s;
@@ -219,14 +177,13 @@ export class SendService implements SendServiceAbstraction {
    await this.replace(sends);
  }

-  async replace(sends: { [id: string]: SendData }): Promise<any> {
-    await this.stateService.setDecryptedSends(null);
-    await this.stateService.setEncryptedSends(sends);
-  }
-
-  async clear(): Promise<any> {
-    await this.stateService.setDecryptedSends(null);
-    await this.stateService.setEncryptedSends(null);
+  async clear(userId?: string): Promise<any> {
+    if (userId == null || userId == (await this.stateService.getUserId())) {
+      this._sends.next([]);
+      this._sendViews.next([]);
+    }
+    await this.stateService.setDecryptedSends(null, { userId: userId });
+    await this.stateService.setEncryptedSends(null, { userId: userId });
  }

  async delete(id: string | string[]): Promise<any> {
@@ -249,15 +206,9 @@ export class SendService implements SendServiceAbstraction {
    await this.replace(sends);
  }

-  async deleteWithServer(id: string): Promise<any> {
-    await this.apiService.deleteSend(id);
-    await this.delete(id);
-  }
-
-  async removePasswordWithServer(id: string): Promise<any> {
-    const response = await this.apiService.putSendRemovePassword(id);
-    const data = new SendData(response);
-    await this.upsert(data);
+  async replace(sends: { [id: string]: SendData }): Promise<any> {
+    await this.updateObservables(sends);
+    await this.stateService.setEncryptedSends(sends);
  }

  private parseFile(send: Send, file: File, key: SymmetricCryptoKey): Promise<EncArrayBuffer> {
@@ -292,4 +243,21 @@ export class SendService implements SendServiceAbstraction {
    const encFileData = await this.cryptoService.encryptToBytes(data, key);
    return [encFileName, encFileData];
  }
+
+  private async updateObservables(sendsMap: { [id: string]: SendData }) {
+    const sends = Object.values(sendsMap || {}).map((f) => new Send(f));
+    this._sends.next(sends);
+
+    if (await this.cryptoService.hasKey()) {
+      this._sendViews.next(await this.decryptSends(sends));
+    }
+  }
+
+  private async decryptSends(sends: Send[]) {
+    const decryptSendPromises = sends.map((s) => s.decrypt());
+    const decryptedSends = await Promise.all(decryptSendPromises);
+
+    decryptedSends.sort(Utils.getSortFunction(this.i18nService, "name"));
+    return decryptedSends;
+  }
 }
--- a/libs/common/src/vault/abstractions/file-upload/cipher-file-upload.service.ts
+++ b/libs/common/src/vault/abstractions/file-upload/cipher-file-upload.service.ts
@@ -0,0 +1,15 @@
+import { EncArrayBuffer } from "../../../models/domain/enc-array-buffer";
+import { EncString } from "../../../models/domain/enc-string";
+import { SymmetricCryptoKey } from "../../../models/domain/symmetric-crypto-key";
+import { Cipher } from "../../models/domain/cipher";
+import { CipherResponse } from "../../models/response/cipher.response";
+
+export abstract class CipherFileUploadService {
+  upload: (
+    cipher: Cipher,
+    encFileName: EncString,
+    encData: EncArrayBuffer,
+    admin: boolean,
+    dataEncKey: [SymmetricCryptoKey, EncString]
+  ) => Promise<CipherResponse>;
+}
--- a/libs/common/src/vault/services/cipher.service.spec.ts
+++ b/libs/common/src/vault/services/cipher.service.spec.ts
@@ -4,7 +4,6 @@ import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
 import { ApiService } from "../../abstractions/api.service";
 import { CryptoService } from "../../abstractions/crypto.service";
 import { EncryptService } from "../../abstractions/encrypt.service";
-import { FileUploadService } from "../../abstractions/fileUpload.service";
 import { I18nService } from "../../abstractions/i18n.service";
 import { LogService } from "../../abstractions/log.service";
 import { SearchService } from "../../abstractions/search.service";
@@ -13,6 +12,7 @@ import { StateService } from "../../abstractions/state.service";
 import { EncArrayBuffer } from "../../models/domain/enc-array-buffer";
 import { EncString } from "../../models/domain/enc-string";
 import { SymmetricCryptoKey } from "../../models/domain/symmetric-crypto-key";
+import { CipherFileUploadService } from "../abstractions/file-upload/cipher-file-upload.service";
 import { Cipher } from "../models/domain/cipher";

 import { CipherService } from "./cipher.service";
@@ -25,7 +25,7 @@ describe("Cipher Service", () => {
  let stateService: SubstituteOf<StateService>;
  let settingsService: SubstituteOf<SettingsService>;
  let apiService: SubstituteOf<ApiService>;
-  let fileUploadService: SubstituteOf<FileUploadService>;
+  let cipherFileUploadService: SubstituteOf<CipherFileUploadService>;
  let i18nService: SubstituteOf<I18nService>;
  let searchService: SubstituteOf<SearchService>;
  let logService: SubstituteOf<LogService>;
@@ -38,7 +38,7 @@ describe("Cipher Service", () => {
    stateService = Substitute.for<StateService>();
    settingsService = Substitute.for<SettingsService>();
    apiService = Substitute.for<ApiService>();
-    fileUploadService = Substitute.for<FileUploadService>();
+    cipherFileUploadService = Substitute.for<CipherFileUploadService>();
    i18nService = Substitute.for<I18nService>();
    searchService = Substitute.for<SearchService>();
    logService = Substitute.for<LogService>();
@@ -51,12 +51,12 @@ describe("Cipher Service", () => {
      cryptoService,
      settingsService,
      apiService,
-      fileUploadService,
      i18nService,
      () => searchService,
      logService,
      stateService,
-      encryptService
+      encryptService,
+      cipherFileUploadService
    );
  });

@@ -67,8 +67,8 @@ describe("Cipher Service", () => {

    await cipherService.saveAttachmentRawWithServer(new Cipher(), fileName, fileData);

-    fileUploadService
+    cipherFileUploadService
      .received(1)
-      .uploadCipherAttachment(Arg.any(), Arg.any(), new EncString(ENCRYPTED_TEXT), ENCRYPTED_BYTES);
+      .upload(Arg.any(), Arg.any(), ENCRYPTED_BYTES, Arg.any(), Arg.any());
  });
 });
--- a/libs/common/src/vault/services/cipher.service.ts
+++ b/libs/common/src/vault/services/cipher.service.ts
@@ -3,7 +3,6 @@ import { firstValueFrom } from "rxjs";
 import { ApiService } from "../../abstractions/api.service";
 import { CryptoService } from "../../abstractions/crypto.service";
 import { EncryptService } from "../../abstractions/encrypt.service";
-import { FileUploadService } from "../../abstractions/fileUpload.service";
 import { I18nService } from "../../abstractions/i18n.service";
 import { LogService } from "../../abstractions/log.service";
 import { SearchService } from "../../abstractions/search.service";
@@ -21,6 +20,7 @@ import { SymmetricCryptoKey } from "../../models/domain/symmetric-crypto-key";
 import { ErrorResponse } from "../../models/response/error.response";
 import { View } from "../../models/view/view";
 import { CipherService as CipherServiceAbstraction } from "../abstractions/cipher.service";
+import { CipherFileUploadService } from "../abstractions/file-upload/cipher-file-upload.service";
 import { CipherType } from "../enums/cipher-type";
 import { CipherData } from "../models/data/cipher.data";
 import { Attachment } from "../models/domain/attachment";
@@ -33,7 +33,6 @@ import { LoginUri } from "../models/domain/login-uri";
 import { Password } from "../models/domain/password";
 import { SecureNote } from "../models/domain/secure-note";
 import { SortedCiphersCache } from "../models/domain/sorted-ciphers-cache";
-import { AttachmentRequest } from "../models/request/attachment.request";
 import { CipherBulkDeleteRequest } from "../models/request/cipher-bulk-delete.request";
 import { CipherBulkMoveRequest } from "../models/request/cipher-bulk-move.request";
 import { CipherBulkRestoreRequest } from "../models/request/cipher-bulk-restore.request";
@@ -58,12 +57,12 @@ export class CipherService implements CipherServiceAbstraction {
    private cryptoService: CryptoService,
    private settingsService: SettingsService,
    private apiService: ApiService,
-    private fileUploadService: FileUploadService,
    private i18nService: I18nService,
    private searchService: () => SearchService,
    private logService: LogService,
    private stateService: StateService,
-    private encryptService: EncryptService
+    private encryptService: EncryptService,
+    private cipherFileUploadService: CipherFileUploadService
  ) {}

  async getDecryptedCipherCache(): Promise<CipherView[]> {
@@ -725,41 +724,13 @@ export class CipherService implements CipherServiceAbstraction {
    const dataEncKey = await this.cryptoService.makeEncKey(key);
    const encData = await this.cryptoService.encryptToBytes(data, dataEncKey[0]);

-    const request: AttachmentRequest = {
-      key: dataEncKey[1].encryptedString,
-      fileName: encFileName.encryptedString,
-      fileSize: encData.buffer.byteLength,
-      adminRequest: admin,
-    };
-
-    let response: CipherResponse;
-    try {
-      const uploadDataResponse = await this.apiService.postCipherAttachment(cipher.id, request);
-      response = admin ? uploadDataResponse.cipherMiniResponse : uploadDataResponse.cipherResponse;
-      await this.fileUploadService.uploadCipherAttachment(
-        admin,
-        uploadDataResponse,
-        encFileName,
-        encData
-      );
-    } catch (e) {
-      if (
-        (e instanceof ErrorResponse && (e as ErrorResponse).statusCode === 404) ||
-        (e as ErrorResponse).statusCode === 405
-      ) {
-        response = await this.legacyServerAttachmentFileUpload(
-          admin,
-          cipher.id,
-          encFileName,
-          encData,
-          dataEncKey[1]
-        );
-      } else if (e instanceof ErrorResponse) {
-        throw new Error((e as ErrorResponse).getSingleMessage());
-      } else {
-        throw e;
-      }
-    }
+    const response = await this.cipherFileUploadService.upload(
+      cipher,
+      encFileName,
+      encData,
+      admin,
+      dataEncKey
+    );

    const cData = new CipherData(response, cipher.collectionIds);
    if (!admin) {
@@ -768,52 +739,6 @@ export class CipherService implements CipherServiceAbstraction {
    return new Cipher(cData);
  }

-  /**
-   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
-   * This method still exists for backward compatibility with old server versions.
-   */
-  async legacyServerAttachmentFileUpload(
-    admin: boolean,
-    cipherId: string,
-    encFileName: EncString,
-    encData: EncArrayBuffer,
-    key: EncString
-  ) {
-    const fd = new FormData();
-    try {
-      const blob = new Blob([encData.buffer], { type: "application/octet-stream" });
-      fd.append("key", key.encryptedString);
-      fd.append("data", blob, encFileName.encryptedString);
-    } catch (e) {
-      if (Utils.isNode && !Utils.isBrowser) {
-        fd.append("key", key.encryptedString);
-        fd.append(
-          "data",
-          Buffer.from(encData.buffer) as any,
-          {
-            filepath: encFileName.encryptedString,
-            contentType: "application/octet-stream",
-          } as any
-        );
-      } else {
-        throw e;
-      }
-    }
-
-    let response: CipherResponse;
-    try {
-      if (admin) {
-        response = await this.apiService.postCipherAttachmentAdminLegacy(cipherId, fd);
-      } else {
-        response = await this.apiService.postCipherAttachmentLegacy(cipherId, fd);
-      }
-    } catch (e) {
-      throw new Error((e as ErrorResponse).getSingleMessage());
-    }
-
-    return response;
-  }
-
  async saveCollectionsWithServer(cipher: Cipher): Promise<any> {
    const request = new CipherCollectionsRequest(cipher.collectionIds);
    await this.apiService.putCipherCollections(cipher.id, request);
--- a/libs/common/src/vault/services/file-upload/cipher-file-upload.service.ts
+++ b/libs/common/src/vault/services/file-upload/cipher-file-upload.service.ts
@@ -0,0 +1,157 @@
+import { ApiService } from "../../../abstractions/api.service";
+import {
+  FileUploadApiMethods,
+  FileUploadService,
+} from "../../../abstractions/file-upload/file-upload.service";
+import { Utils } from "../../../misc/utils";
+import { EncArrayBuffer } from "../../../models/domain/enc-array-buffer";
+import { EncString } from "../../../models/domain/enc-string";
+import { SymmetricCryptoKey } from "../../../models/domain/symmetric-crypto-key";
+import { ErrorResponse } from "../../../models/response/error.response";
+import { CipherFileUploadService as CipherFileUploadServiceAbstraction } from "../../abstractions/file-upload/cipher-file-upload.service";
+import { Cipher } from "../../models/domain/cipher";
+import { AttachmentRequest } from "../../models/request/attachment.request";
+import { AttachmentUploadDataResponse } from "../../models/response/attachment-upload-data.response";
+import { CipherResponse } from "../../models/response/cipher.response";
+
+export class CipherFileUploadService implements CipherFileUploadServiceAbstraction {
+  constructor(private apiService: ApiService, private fileUploadService: FileUploadService) {}
+
+  async upload(
+    cipher: Cipher,
+    encFileName: EncString,
+    encData: EncArrayBuffer,
+    admin: boolean,
+    dataEncKey: [SymmetricCryptoKey, EncString]
+  ): Promise<CipherResponse> {
+    const request: AttachmentRequest = {
+      key: dataEncKey[1].encryptedString,
+      fileName: encFileName.encryptedString,
+      fileSize: encData.buffer.byteLength,
+      adminRequest: admin,
+    };
+
+    let response: CipherResponse;
+    try {
+      const uploadDataResponse = await this.apiService.postCipherAttachment(cipher.id, request);
+      response = admin ? uploadDataResponse.cipherMiniResponse : uploadDataResponse.cipherResponse;
+      await this.fileUploadService.upload(
+        uploadDataResponse,
+        encFileName,
+        encData,
+        this.generateMethods(uploadDataResponse, response, request.adminRequest)
+      );
+    } catch (e) {
+      if (
+        (e instanceof ErrorResponse && (e as ErrorResponse).statusCode === 404) ||
+        (e as ErrorResponse).statusCode === 405
+      ) {
+        response = await this.legacyServerAttachmentFileUpload(
+          request.adminRequest,
+          cipher.id,
+          encFileName,
+          encData,
+          dataEncKey[1]
+        );
+      } else if (e instanceof ErrorResponse) {
+        throw new Error((e as ErrorResponse).getSingleMessage());
+      } else {
+        throw e;
+      }
+    }
+    return response;
+  }
+
+  private generateMethods(
+    uploadData: AttachmentUploadDataResponse,
+    response: CipherResponse,
+    isAdmin: boolean
+  ): FileUploadApiMethods {
+    return {
+      postDirect: this.generatePostDirectCallback(uploadData, isAdmin),
+      renewFileUploadUrl: this.generateRenewFileUploadUrlCallback(uploadData, response, isAdmin),
+      rollback: this.generateRollbackCallback(response, uploadData, isAdmin),
+    };
+  }
+
+  private generatePostDirectCallback(uploadData: AttachmentUploadDataResponse, isAdmin: boolean) {
+    return (data: FormData) => {
+      const response = isAdmin ? uploadData.cipherMiniResponse : uploadData.cipherResponse;
+      return this.apiService.postAttachmentFile(response.id, uploadData.attachmentId, data);
+    };
+  }
+
+  private generateRenewFileUploadUrlCallback(
+    uploadData: AttachmentUploadDataResponse,
+    response: CipherResponse,
+    isAdmin: boolean
+  ) {
+    return async () => {
+      const renewResponse = await this.apiService.renewAttachmentUploadUrl(
+        response.id,
+        uploadData.attachmentId
+      );
+      return renewResponse?.url;
+    };
+  }
+
+  private generateRollbackCallback(
+    response: CipherResponse,
+    uploadData: AttachmentUploadDataResponse,
+    isAdmin: boolean
+  ) {
+    return () => {
+      if (isAdmin) {
+        return this.apiService.deleteCipherAttachmentAdmin(response.id, uploadData.attachmentId);
+      } else {
+        return this.apiService.deleteCipherAttachment(response.id, uploadData.attachmentId);
+      }
+    };
+  }
+
+  /**
+   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
+   * This method still exists for backward compatibility with old server versions.
+   */
+  async legacyServerAttachmentFileUpload(
+    admin: boolean,
+    cipherId: string,
+    encFileName: EncString,
+    encData: EncArrayBuffer,
+    key: EncString
+  ) {
+    const fd = new FormData();
+    try {
+      const blob = new Blob([encData.buffer], { type: "application/octet-stream" });
+      fd.append("key", key.encryptedString);
+      fd.append("data", blob, encFileName.encryptedString);
+    } catch (e) {
+      if (Utils.isNode && !Utils.isBrowser) {
+        fd.append("key", key.encryptedString);
+        fd.append(
+          "data",
+          Buffer.from(encData.buffer) as any,
+          {
+            filepath: encFileName.encryptedString,
+            contentType: "application/octet-stream",
+          } as any
+        );
+      } else {
+        throw e;
+      }
+    }
+
+    let response: CipherResponse;
+    try {
+      if (admin) {
+        response = await this.apiService.postCipherAttachmentAdminLegacy(cipherId, fd);
+      } else {
+        response = await this.apiService.postCipherAttachmentLegacy(cipherId, fd);
+      }
+    } catch (e) {
+      throw new Error((e as ErrorResponse).getSingleMessage());
+    }
+
+    return response;
+  }
+}
--- a/libs/common/src/vault/services/sync/sync.service.ts
+++ b/libs/common/src/vault/services/sync/sync.service.ts
@@ -2,7 +2,8 @@ import { ApiService } from "../../../abstractions/api.service";
 import { CryptoService } from "../../../abstractions/crypto.service";
 import { LogService } from "../../../abstractions/log.service";
 import { MessagingService } from "../../../abstractions/messaging.service";
-import { SendService } from "../../../abstractions/send.service";
+import { SendApiService } from "../../../abstractions/send/send-api.service.abstraction";
+import { InternalSendService } from "../../../abstractions/send/send.service.abstraction";
 import { SettingsService } from "../../../abstractions/settings.service";
 import { StateService } from "../../../abstractions/state.service";
 import { CollectionService } from "../../../admin-console/abstractions/collection.service";
@@ -47,13 +48,14 @@ export class SyncService implements SyncServiceAbstraction {
    private collectionService: CollectionService,
    private messagingService: MessagingService,
    private policyService: InternalPolicyService,
-    private sendService: SendService,
+    private sendService: InternalSendService,
    private logService: LogService,
    private keyConnectorService: KeyConnectorService,
    private stateService: StateService,
    private providerService: ProviderService,
    private folderApiService: FolderApiServiceAbstraction,
    private organizationService: InternalOrganizationService,
+    private sendApiService: SendApiService,
    private logoutCallback: (expired: boolean) => Promise<void>
  ) {}

@@ -230,12 +232,12 @@ export class SyncService implements SyncServiceAbstraction {
    this.syncStarted();
    if (await this.stateService.getIsAuthenticated()) {
      try {
-        const localSend = await this.sendService.get(notification.id);
+        const localSend = this.sendService.get(notification.id);
        if (
          (!isEdit && localSend == null) ||
          (isEdit && localSend != null && localSend.revisionDate < notification.revisionDate)
        ) {
-          const remoteSend = await this.apiService.getSend(notification.id);
+          const remoteSend = await this.sendApiService.getSend(notification.id);
          if (remoteSend != null) {
            await this.sendService.upsert(new SendData(remoteSend));
            this.messagingService.send("syncedUpsertedSend", { sendId: notification.id });