feat: download and preview files from local backups automatically, if a local backup is available (#2076)

packages/services/src/Domain/Backups/BackupService.spec.ts

@@ -0,0 +1,109 @@
+import { StatusServiceInterface } from './../Status/StatusServiceInterface'
+import { FilesBackupService } from './BackupService'
+import { PureCryptoInterface, StreamEncryptor } from '@standardnotes/sncrypto-common'
+import { EncryptionProviderInterface } from '@standardnotes/encryption'
+import { ItemManagerInterface } from '../Item/ItemManagerInterface'
+import { InternalEventBusInterface } from '..'
+import { AlertService } from '../Alert/AlertService'
+import { ApiServiceInterface } from '../Api/ApiServiceInterface'
+import { SyncServiceInterface } from '../Sync/SyncServiceInterface'
+import { FileBackupsDevice } from '@standardnotes/files'
+
+describe('backup service', () => {
+  let apiService: ApiServiceInterface
+  let itemManager: ItemManagerInterface
+  let syncService: SyncServiceInterface
+  let alertService: AlertService
+  let crypto: PureCryptoInterface
+  let status: StatusServiceInterface
+  let encryptor: EncryptionProviderInterface
+  let internalEventBus: InternalEventBusInterface
+  let backupService: FilesBackupService
+  let device: FileBackupsDevice
+
+  beforeEach(() => {
+    apiService = {} as jest.Mocked<ApiServiceInterface>
+    apiService.addEventObserver = jest.fn()
+    apiService.createFileValetToken = jest.fn()
+    apiService.downloadFile = jest.fn()
+    apiService.deleteFile = jest.fn().mockReturnValue({})
+
+    itemManager = {} as jest.Mocked<ItemManagerInterface>
+    itemManager.createItem = jest.fn()
+    itemManager.createTemplateItem = jest.fn().mockReturnValue({})
+    itemManager.setItemToBeDeleted = jest.fn()
+    itemManager.addObserver = jest.fn()
+    itemManager.changeItem = jest.fn()
+
+    status = {} as jest.Mocked<StatusServiceInterface>
+
+    device = {} as jest.Mocked<FileBackupsDevice>
+    device.getFileBackupReadToken = jest.fn()
+    device.readNextChunk = jest.fn()
+
+    syncService = {} as jest.Mocked<SyncServiceInterface>
+    syncService.sync = jest.fn()
+
+    encryptor = {} as jest.Mocked<EncryptionProviderInterface>
+
+    alertService = {} as jest.Mocked<AlertService>
+    alertService.confirm = jest.fn().mockReturnValue(true)
+    alertService.alert = jest.fn()
+
+    crypto = {} as jest.Mocked<PureCryptoInterface>
+    crypto.base64Decode = jest.fn()
+    internalEventBus = {} as jest.Mocked<InternalEventBusInterface>
+    internalEventBus.publish = jest.fn()
+
+    backupService = new FilesBackupService(itemManager, apiService, encryptor, device, status, crypto, internalEventBus)
+
+    crypto.xchacha20StreamInitDecryptor = jest.fn().mockReturnValue({
+      state: {},
+    } as StreamEncryptor)
+
+    crypto.xchacha20StreamDecryptorPush = jest.fn().mockReturnValue({ message: new Uint8Array([0xaa]), tag: 0 })
+
+    crypto.xchacha20StreamInitEncryptor = jest.fn().mockReturnValue({
+      header: 'some-header',
+      state: {},
+    } as StreamEncryptor)
+
+    crypto.xchacha20StreamEncryptorPush = jest.fn().mockReturnValue(new Uint8Array())
+  })
+
+  describe('readEncryptedFileFromBackup', () => {
+    it('return failed if no backup', async () => {
+      backupService.getFileBackupInfo = jest.fn().mockReturnValue(undefined)
+
+      const result = await backupService.readEncryptedFileFromBackup('123', async () => {})
+
+      expect(result).toEqual('failed')
+    })
+
+    it('return success if backup', async () => {
+      backupService.getFileBackupInfo = jest.fn().mockReturnValue({})
+
+      device.readNextChunk = jest.fn().mockReturnValue({ chunk: new Uint8Array([]), isLast: true, progress: undefined })
+
+      const result = await backupService.readEncryptedFileFromBackup('123', async () => {})
+
+      expect(result).toEqual('success')
+    })
+
+    it('should loop through all chunks until last', async () => {
+      backupService.getFileBackupInfo = jest.fn().mockReturnValue({})
+      const expectedChunkCount = 3
+      let receivedChunkCount = 0
+
+      const mockFn = (device.readNextChunk = jest.fn().mockImplementation(() => {
+        receivedChunkCount++
+
+        return { chunk: new Uint8Array([]), isLast: receivedChunkCount === expectedChunkCount, progress: undefined }
+      }))
+
+      await backupService.readEncryptedFileFromBackup('123', async () => {})
+
+      expect(mockFn.mock.calls.length).toEqual(expectedChunkCount)
+    })
+  })
+})

packages/services/src/Domain/Backups/BackupService.ts

@@ -8,13 +8,17 @@ import {
   FileBackupsDevice,
   FileBackupsMapping,
   FileBackupRecord,
+  OnChunkCallback,
+  BackupServiceInterface,
 } from '@standardnotes/files'
 import { InternalEventBusInterface } from '../Internal/InternalEventBusInterface'
 import { ItemManagerInterface } from '../Item/ItemManagerInterface'
 import { AbstractService } from '../Service/AbstractService'
 import { StatusServiceInterface } from '../Status/StatusServiceInterface'
+import { PureCryptoInterface } from '@standardnotes/sncrypto-common'
+import { log, LoggingDomain } from '../Logging'
 
-export class FilesBackupService extends AbstractService {
+export class FilesBackupService extends AbstractService implements BackupServiceInterface {
   private itemsObserverDisposer: () => void
   private pendingFiles = new Set<Uuid>()
   private mappingCache?: FileBackupsMapping['files']
@@ -25,6 +29,7 @@ export class FilesBackupService extends AbstractService {
     private encryptor: EncryptionProviderInterface,
     private device: FileBackupsDevice,
     private status: StatusServiceInterface,
+    private crypto: PureCryptoInterface,
     protected override internalEventBus: InternalEventBusInterface,
   ) {
     super(internalEventBus)
@@ -43,7 +48,14 @@ export class FilesBackupService extends AbstractService {
   }
 
   override deinit() {
+    super.deinit()
     this.itemsObserverDisposer()
+    ;(this.items as unknown) = undefined
+    ;(this.api as unknown) = undefined
+    ;(this.encryptor as unknown) = undefined
+    ;(this.device as unknown) = undefined
+    ;(this.status as unknown) = undefined
+    ;(this.crypto as unknown) = undefined
   }
 
   public isFilesBackupsEnabled(): Promise<boolean> {
@@ -98,7 +110,7 @@ export class FilesBackupService extends AbstractService {
     return this.mappingCache ?? (await this.getBackupsMappingFromDisk())
   }
 
-  public async getFileBackupInfo(file: FileItem): Promise<FileBackupRecord | undefined> {
+  public async getFileBackupInfo(file: { uuid: string }): Promise<FileBackupRecord | undefined> {
     const mapping = await this.getBackupsMappingFromCache()
     const record = mapping[file.uuid]
     return record
@@ -138,7 +150,34 @@ export class FilesBackupService extends AbstractService {
     this.invalidateMappingCache()
   }
 
+  async readEncryptedFileFromBackup(uuid: string, onChunk: OnChunkCallback): Promise<'success' | 'failed' | 'aborted'> {
+    const fileBackup = await this.getFileBackupInfo({ uuid })
+
+    if (!fileBackup) {
+      return 'failed'
+    }
+
+    const token = await this.device.getFileBackupReadToken(fileBackup)
+
+    let readMore = true
+    let index = 0
+
+    while (readMore) {
+      const { chunk, isLast, progress } = await this.device.readNextChunk(token)
+
+      await onChunk({ data: chunk, index, isLast, progress })
+
+      readMore = !isLast
+
+      index++
+    }
+
+    return 'success'
+  }
+
   private async performBackupOperation(file: FileItem): Promise<'success' | 'failed' | 'aborted'> {
+    log(LoggingDomain.FilesBackups, 'Backing up file locally', file.uuid)
+
     const messageId = this.status.addMessage(`Backing up file ${file.name}...`)
 
     const encryptedFile = await this.encryptor.encryptSplitSingle({