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

packages/files/src/Domain/Service/BackupServiceInterface.ts

@@ -0,0 +1,14 @@
+import { OnChunkCallback } from '../Chunker/OnChunkCallback'
+import { FileBackupRecord } from '../Device/FileBackupsMapping'
+
+export interface BackupServiceInterface {
+  getFileBackupInfo(file: { uuid: string }): Promise<FileBackupRecord | undefined>
+  readEncryptedFileFromBackup(uuid: string, onChunk: OnChunkCallback): Promise<'success' | 'failed' | 'aborted'>
+  isFilesBackupsEnabled(): Promise<boolean>
+  enableFilesBackups(): Promise<void>
+  disableFilesBackups(): Promise<void>
+  changeFilesBackupsLocation(): Promise<string | undefined>
+  getFilesBackupsLocation(): Promise<string>
+  openFilesBackupsLocation(): Promise<void>
+  openFileBackup(record: FileBackupRecord): Promise<void>
+}

packages/files/src/Domain/Service/FilesClientInterface.ts

@@ -24,7 +24,7 @@ export interface FilesClientInterface {
 
   downloadFile(
     file: FileItem,
-    onDecryptedBytes: (bytes: Uint8Array, progress: FileDownloadProgress | undefined) => Promise<void>,
+    onDecryptedBytes: (bytes: Uint8Array, progress: FileDownloadProgress) => Promise<void>,
   ): Promise<ClientDisplayableError | undefined>
 
   deleteFile(file: FileItem): Promise<ClientDisplayableError | undefined>

packages/files/src/Domain/Service/ReadAndDecryptBackupFileFileSystemAPI.ts

@@ -5,7 +5,7 @@ import { FileSystemApi } from '../Api/FileSystemApi'
 import { FileHandleRead } from '../Api/FileHandleRead'
 import { OrderedByteChunker } from '../Chunker/OrderedByteChunker'
 
-export async function readAndDecryptBackupFile(
+export async function readAndDecryptBackupFileUsingFileSystemAPI(
   fileHandle: FileHandleRead,
   file: {
     encryptionHeader: FileContent['encryptionHeader']
@@ -19,8 +19,8 @@ export async function readAndDecryptBackupFile(
 ): Promise<'aborted' | 'failed' | 'success'> {
   const decryptor = new FileDecryptor(file, crypto)
 
-  const byteChunker = new OrderedByteChunker(file.encryptedChunkSizes, async (chunk: Uint8Array) => {
-    const decryptResult = decryptor.decryptBytes(chunk)
+  const byteChunker = new OrderedByteChunker(file.encryptedChunkSizes, 'local', async (chunk) => {
+    const decryptResult = decryptor.decryptBytes(chunk.data)
 
     if (!decryptResult) {
       return

packages/files/src/Domain/Service/ReadAndDecryptBackupFileUsingBackupService.ts

@@ -0,0 +1,52 @@
+import { FileContent } from '@standardnotes/models'
+import { PureCryptoInterface } from '@standardnotes/sncrypto-common'
+import { FileDecryptor } from '../UseCase/FileDecryptor'
+import { OrderedByteChunker } from '../Chunker/OrderedByteChunker'
+import { BackupServiceInterface } from './BackupServiceInterface'
+import { OnChunkCallback } from '../Chunker/OnChunkCallback'
+import { log, LoggingDomain } from '../Logging'
+
+export async function readAndDecryptBackupFileUsingBackupService(
+  file: {
+    uuid: string
+    encryptionHeader: FileContent['encryptionHeader']
+    remoteIdentifier: FileContent['remoteIdentifier']
+    encryptedChunkSizes: FileContent['encryptedChunkSizes']
+    key: FileContent['key']
+  },
+  backupService: BackupServiceInterface,
+  crypto: PureCryptoInterface,
+  onDecryptedBytes: OnChunkCallback,
+): Promise<'aborted' | 'failed' | 'success'> {
+  log(
+    LoggingDomain.FilesPackage,
+    'Reading and decrypting backup file',
+    file.uuid,
+    'chunk sizes',
+    file.encryptedChunkSizes,
+  )
+
+  const decryptor = new FileDecryptor(file, crypto)
+
+  const byteChunker = new OrderedByteChunker(file.encryptedChunkSizes, 'local', async (chunk) => {
+    log(LoggingDomain.FilesPackage, 'OrderedByteChunker did pop bytes', chunk.data.length, chunk.progress)
+
+    const decryptResult = decryptor.decryptBytes(chunk.data)
+
+    if (!decryptResult) {
+      return
+    }
+
+    await onDecryptedBytes({ ...chunk, data: decryptResult.decryptedBytes })
+  })
+
+  const readResult = await backupService.readEncryptedFileFromBackup(file.uuid, async (chunk) => {
+    log(LoggingDomain.FilesPackage, 'Got file chunk from backup service', chunk.data.length, chunk.progress)
+
+    await byteChunker.addBytes(chunk.data)
+  })
+
+  log(LoggingDomain.FilesPackage, 'Finished reading and decrypting backup file', file.uuid)
+
+  return readResult
+}