feat: Clean non-important offline files when too old

As we store offline accessible files in the device's storage, we want
to prevent them to fill the entire device's storage

We chose to keep only files that were accessed in the previous month.
All other files would be deleted

Important files are never deleted as long as they exist on the Cozy
instance

src/app/domain/io.cozy.files/importantFiles.ts

@@ -1,4 +1,8 @@
+import { differenceInMonths } from 'date-fns'
+import RNFS from 'react-native-fs'
+
 import CozyClient from 'cozy-client'
+import type { FileDocument } from 'cozy-client/types/types'
 import Minilog from 'cozy-minilog'
 
 import { downloadFile } from '/app/domain/io.cozy.files/offlineFiles'
@@ -12,6 +16,7 @@ import { getErrorMessage } from '/libs/functions/getErrorMessage'
 const log = Minilog('📁 Offline Files')
 
 const IMPORTANT_FILES_DOWNLOAD_DELAY_IN_MS = 100
+const NB_OF_MONTH_BEFORE_EXPIRATION = 1
 
 export const makeImportantFilesAvailableOfflineInBackground = (
   client: CozyClient
@@ -37,8 +42,47 @@ const makeImportantFilesAvailableOffline = async (
   log.debug('Start downloading important files for offline support')
   const importantFiles = await getImportantFiles(client)
 
+  await cleanOldNonImportantFiles(importantFiles)
+
   for (const importantFile of importantFiles) {
     log.debug(`Start downloading file ${importantFile._id}`)
     await downloadFile(importantFile, client)
   }
 }
+
+const cleanOldNonImportantFiles = async (
+  importantFiles: FileDocument[]
+): Promise<void> => {
+  try {
+    const offlineFiles = await getOfflineFilesConfiguration()
+    const offlineFilesMap = Array.from(offlineFiles)
+
+    const importantFilesIds = importantFiles.map(file => file._id)
+
+    const now = new Date()
+
+    for (const [, offlineFile] of offlineFilesMap) {
+      const lastOpened = offlineFile.lastOpened
+      if (
+        !importantFilesIds.includes(offlineFile.id) &&
+        (differenceInMonths(lastOpened, now) > NB_OF_MONTH_BEFORE_EXPIRATION ||
+          !lastOpened)
+      ) {
+        log.debug(
+          `Remove old unimportant file ${
+            offlineFile.id
+          } (last opened on ${lastOpened.toString()})`
+        )
+        if (await RNFS.exists(offlineFile.path)) {
+          await RNFS.unlink(offlineFile.path)
+        }
+        await removeOfflineFileFromConfiguration(offlineFile.id)
+      }
+    }
+  } catch (error) {
+    const errorMessage = getErrorMessage(error)
+    log.error(
+      `Something went wrong while cleaning non-important files: ${errorMessage}`
+    )
+  }
+}

src/app/domain/io.cozy.files/offlineFiles.spec.ts

@@ -10,7 +10,8 @@ import {
 import {
   addOfflineFileToConfiguration,
   getOfflineFileFromConfiguration,
-  OfflineFile
+  OfflineFile,
+  updateLastOpened
 } from '/app/domain/io.cozy.files/offlineFilesConfiguration'
 import {
   getDownloadUrlById,
@@ -22,7 +23,8 @@ jest.mock('react-native-file-viewer', () => ({
 }))
 jest.mock('/app/domain/io.cozy.files/offlineFilesConfiguration', () => ({
   addOfflineFileToConfiguration: jest.fn(),
-  getOfflineFileFromConfiguration: jest.fn()
+  getOfflineFileFromConfiguration: jest.fn(),
+  updateLastOpened: jest.fn()
 }))
 jest.mock('/app/domain/io.cozy.files/remoteFiles', () => ({
   getFileById: jest.fn(),
@@ -139,6 +141,27 @@ describe('offlineFiles', () => {
       expect(addOfflineFileToConfiguration).not.toHaveBeenCalled()
     })
 
+    it('should update lastOpened attribute if file exists', async () => {
+      mockRemoteFile({
+        _id: 'SOME_FILE_ID',
+        _rev: 'SOME_REV',
+        name: 'SOME_FILE_NAME'
+      })
+      mockFileFromConfiguration({
+        id: 'SOME_FILE_ID',
+        rev: 'SOME_REV',
+        path: 'SOME_EXISTING_PATH_FROM_CACHE',
+        lastOpened: new Date()
+      })
+      const file = {
+        _id: 'SOME_FILE_ID',
+        name: 'SOME_FILE_NAME'
+      } as unknown as FileDocument
+      await downloadFile(file, mockClient)
+
+      expect(updateLastOpened).toHaveBeenCalledWith('SOME_FILE_ID')
+    })
+
     it('should download file if existing but with different rev', async () => {
       mockRemoteFile({
         _id: 'SOME_FILE_ID',

src/app/domain/io.cozy.files/offlineFiles.ts

@@ -7,7 +7,8 @@ import Minilog from 'cozy-minilog'
 
 import {
   addOfflineFileToConfiguration,
-  getOfflineFileFromConfiguration
+  getOfflineFileFromConfiguration,
+  updateLastOpened
 } from '/app/domain/io.cozy.files/offlineFilesConfiguration'
 import {
   getDownloadUrlById,
@@ -50,6 +51,7 @@ export const downloadFile = async (
 
     if (existingFile && existingFile.rev === remoteFile._rev) {
       log.debug(`File ${file._id} already exist, returning existing one`)
+      await updateLastOpened(file._id)
       return existingFile.path
     }
 

src/app/domain/io.cozy.files/offlineFilesConfiguration.ts

@@ -4,6 +4,7 @@ export interface OfflineFile {
   id: string
   rev: string
   path: string
+  lastOpened: Date
 }
 
 export type OfflineFilesConfiguration = Map<string, OfflineFile>
@@ -20,11 +21,16 @@ export const getOfflineFilesConfiguration =
     return files
   }
 
-export const addOfflineFileToConfiguration = async (file: OfflineFile) => {
+export const addOfflineFileToConfiguration = async (
+  file: Omit<OfflineFile, 'lastOpened'>
+): Promise<void> => {
   const files = await getOfflineFilesConfiguration()
 
-  files.set(file.id, file)
-
+  files.set(file.id, {
+    ...file,
+    lastOpened: new Date()
+  })
+
   const filesArray = Array.from(files.entries())
 
   return storeData(CozyPersistedStorageKeys.OfflineFiles, filesArray)
@@ -53,3 +59,17 @@ export const getOfflineFileFromConfiguration = async (
 
   return undefined
 }
+
+export const updateLastOpened = async (fileId: string): Promise<void> => {
+  const file = await getOfflineFileFromConfiguration(fileId)
+
+  if (!file) {
+    throw new Error(
+      `Cannot update 'lastOpened' attribute for not existing file ${fileId}`
+    )
+  }
+
+  file.lastOpened = new Date()
+
+  await addOfflineFileToConfiguration(file)
+}