diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/auth/SessionManager.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/auth/SessionManager.kt index d850a23..9f46856 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/auth/SessionManager.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/auth/SessionManager.kt @@ -1,5 +1,6 @@ package com.kazier.mobile.auth +import com.kazier.mobile.data.local.dao.PendingOperationDao import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.dto.UserDto import com.kazier.mobile.domain.ActiveUserStore @@ -28,6 +29,7 @@ class SessionManager @Inject constructor( private val activeUserStore: ActiveUserStore, private val tokenProvider: TokenProvider, private val localModeStore: LocalModeStore, + private val pendingOperationDao: PendingOperationDao, private val apiClient: ApiClient, ) { @@ -50,16 +52,28 @@ class SessionManager @Inject constructor( suspend fun save(token: String, user: UserDto, expiresAt: Long? = null) = withContext(Dispatchers.IO) { + val previousUserId = activeUserStore.get() tokenStore.save(token, user, expiresAt) activeUserStore.set(user.id) localModeStore.clear() tokenProvider.current = token + // Changement de compte sans sign-out explicite (login de B par + // dessus la session de A) : même purge que `clear()` — la file de + // A ne doit pas partir sous le token de B. Premier login + // (`previousUserId == null`, éventuel travail du mode local) et + // re-login du même compte : file conservée. + if (previousUserId != null && previousUserId != user.id) { + pendingOperationDao.deleteUnpushed() + } } suspend fun clear() = withContext(Dispatchers.IO) { tokenStore.clear() activeUserStore.clear() tokenProvider.current = null + // Sign-out explicite : la file non poussée est abandonnée (C5, voir + // `deleteUnpushed`). Les ops `synced` survivent comme tombstones. + pendingOperationDao.deleteUnpushed() } /** diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/AppDatabase.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/AppDatabase.kt index 196b11a..99f4ede 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/AppDatabase.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/AppDatabase.kt @@ -33,7 +33,7 @@ import com.kazier.mobile.data.local.entity.UserPreferenceEntity FolderEntity::class, UserPreferenceEntity::class, FileEntity::class, PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class, ], - version = 13, + version = 14, exportSchema = false, ) abstract class AppDatabase : RoomDatabase() { diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt index 362ae6c..d96b359 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt @@ -15,6 +15,15 @@ interface FileDao { @Query("SELECT * FROM files ORDER BY name ASC") suspend fun getAll(): List + /** + * Repasse C4 : lignes déjà journalisées (`exists = 0`) dont les octets + * sont peut-être encore sur le disque (journal-first, crash ou refus SAF + * entre la transaction et la suppression physique). Borné pour ne jamais + * bloquer un tick de sync. + */ + @Query("SELECT * FROM files WHERE \"exists\" = 0 AND uri IS NOT NULL ORDER BY updated_at ASC LIMIT :limit") + suspend fun getMissingWithUri(limit: Int): List + @Query("SELECT * FROM files WHERE folder_resource_id = :folderResourceId AND \"exists\" = 1 ORDER BY name ASC") fun observeByFolder(folderResourceId: String): Flow> diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FolderDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FolderDao.kt index 3b50ad6..624686b 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FolderDao.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FolderDao.kt @@ -18,6 +18,14 @@ interface FolderDao { @Query("SELECT * FROM folders ORDER BY name ASC") suspend fun getAll(): List + /** + * Repasse C4 (dossiers) : voir `FileDao.getMissingWithUri`. Un dossier + * n'est re-supprimé physiquement que si toute sa descendance Room est + * aussi `exists = 0` (jamais de suppression d'un arbre encore vivant). + */ + @Query("SELECT * FROM folders WHERE \"exists\" = 0 AND uri IS NOT NULL ORDER BY updated_at ASC LIMIT :limit") + suspend fun getMissingWithUri(limit: Int): List + /** Dossiers créés dans l'app (`created_in_app = 1`) — cibles du picker de déplacement. */ @Query("SELECT * FROM folders WHERE \"created_in_app\" = 1 ORDER BY name ASC") suspend fun getCreatedInApp(): List diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/PendingOperationDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/PendingOperationDao.kt index 50b933f..9f67a10 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/PendingOperationDao.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/PendingOperationDao.kt @@ -38,14 +38,17 @@ interface PendingOperationDao { /** * Invalidation en cascade : un `create_resource` définitivement échoué rend * fautives toutes les ops en attente qui ciblent la même ressource, ainsi - * que les creates enfants (autre `resource_id`, liés via - * `payload.parentResourceId` — le walk émet parent avant enfant, cf. C6). + * que les creates enfants (autre `resource_id`, liés via la colonne + * `parent_resource_id` — le walk émet parent avant enfant, cf. C6). + * Le repli `LIKE` sur le payload ne sert que les lignes pré-v14 sans + * colonne renseignée. */ @Query(""" UPDATE pending_operations SET status = 'failed', updated_at = :now WHERE status = 'pending' AND ( resource_id = :resourceId - OR payload LIKE '%"parentResourceId":"' || :resourceId || '"%' + OR parent_resource_id = :resourceId + OR (parent_resource_id IS NULL AND payload LIKE '%"parentResourceId":"' || :resourceId || '"%') ) """) suspend fun failDescendants(resourceId: String, now: Long) @@ -137,11 +140,43 @@ interface PendingOperationDao { @Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'") suspend fun countPending(): Int + /** Compteur diagnostique par statut (tests, badge « liste des sync »). */ + @Query("SELECT COUNT(*) FROM pending_operations WHERE status = :status") + suspend fun countByStatus(status: String): Int + /** - * Une op `move_resource` encore en attente de push existe-t-elle pour cette - * ressource ? L'antichambre outbox est alors la source de vérité du - * placement : ni le refresh serveur ni le walk SAF ne doivent écraser le - * `folder_resource_id` local avant que le serveur ait accusé le move. + * Abandon de la file non poussée (C5) : supprime les ops `pending` et + * `failed` — jamais les `synced`. Au changement de compte (sign-out, ou + * login d'un autre user), rejouer la file de A sous le token de B + * appliquerait ses mutations dans le scope de B (`NOT_FOUND`, + * `NAME_CONFLICT`, voire créations croisées). Les ops `synced` sont + * conservées : ce sont des tombstones (C3) fondant les gates + * delete/create et le backfill — elles ne sont plus jamais sélectionnées + * (`selectPending` ne lit que `pending`) donc sans risque de rejeu. + */ + @Query("DELETE FROM pending_operations WHERE status IN ('pending', 'failed')") + suspend fun deleteUnpushed(): Int + + /** + * Un `delete_resource` est-il encore en attente de push pour cette + * ressource ? Le walk SAF ne doit alors jamais la ressusciter (`exists = + * 1`) : l'intention de suppression est déjà journalisée (ordre + * journal-first, C4) et la repasse physique va suivre. Sans ce garde, le + * walk réimporterait une ressource que le serveur s'apprête à supprimer. + */ + @Query(""" + SELECT COUNT(*) FROM pending_operations + WHERE resource_id = :resourceId + AND operation = 'delete_resource' + AND status = 'pending' + """) + suspend fun countPendingDeleteOperations(resourceId: String): Int + + /** + * Un `move_resource` est-il encore en attente de push ? Tant que l'op est + * pendante, le `folder_resource_id` local reflète la cible future : ni le + * refresh serveur (qui renvoie l'ancien dossier) ni le walk SAF (snapshot + * périmé) ne doivent l'écraser. */ @Query(""" SELECT COUNT(*) FROM pending_operations diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/PendingOperationEntity.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/PendingOperationEntity.kt index b808fec..8abf94c 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/PendingOperationEntity.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/PendingOperationEntity.kt @@ -24,6 +24,7 @@ import androidx.room.PrimaryKey Index(value = ["status"]), Index(value = ["resource_id"]), Index(value = ["resource_id", "operation", "status"]), + Index(value = ["parent_resource_id"]), ], ) data class PendingOperationEntity( @@ -45,6 +46,15 @@ data class PendingOperationEntity( val operation: String, @ColumnInfo(name = "payload") val payload: String, + /** + * Lien parent→enfant dénormalisé (P8) : `resource_id` du dossier parent + * pour un `create_resource` avec parent (les enfants portent un autre + * `resource_id`). Évite de parser le JSON du payload (`LIKE`) pour la + * cascade d'invalidation — robuste au format de sérialisation Moshi. + * NULL pour les ops sans parent et les lignes pré-v14 (repli LIKE). + */ + @ColumnInfo(name = "parent_resource_id") + val parentResourceId: String? = null, @ColumnInfo(name = "status") val status: String = PendingOpStatus.PENDING, @ColumnInfo(name = "attempts") diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/migration/Migrations.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/migration/Migrations.kt index 247e11e..b370d83 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/migration/Migrations.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/migration/Migrations.kt @@ -99,6 +99,14 @@ object Migrations { db.execSQL("ALTER TABLE `files` ADD COLUMN `processed` INTEGER NOT NULL DEFAULT 0") // Backlog = déjà traité : la file de review ne contient que les // fichiers découverts après l'activation de la fonctionnalité. + // + // Décision M11 (documentée, assumée) : aucun `create_resource` + // rétroactif n'est journalisé pour ce backlog — ces fichiers ne + // seront jamais poussés vers le serveur (ni vizibles en review). + // Un backfill applicatif créerait des doublons serveur pour les + // ressources déjà connues par d'autres chemins (scan, second + // device) sans moyen fiable de les distinguer : la perte silencieuse + // du backlog pré-v6 est préférée à une résurrection massive. db.execSQL("UPDATE `files` SET `processed` = 1") } } @@ -222,7 +230,23 @@ object Migrations { } } + /** + * P8 : colonne `parent_resource_id` dénormalisée (cascade sans parsing + * JSON). Les lignes pré-v14 gardent NULL et restent couvertes par le repli + * `LIKE` de `failDescendants` — pas de backfill (le `json_extract` + * SQLite n'est pas garanti sur tous les niveaux d'API). + */ + private val MIGRATION_13_14 = object : Migration(13, 14) { + override fun migrate(db: SupportSQLiteDatabase) { + db.execSQL("ALTER TABLE `pending_operations` ADD COLUMN `parent_resource_id` TEXT") + db.execSQL( + "CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` " + + "ON `pending_operations` (`parent_resource_id`)", + ) + } + } + val ALL: Array = arrayOf( - MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_11_12, MIGRATION_12_13, + MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_11_12, MIGRATION_12_13, MIGRATION_13_14, ) } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt index 24b1668..be9e39c 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt @@ -186,6 +186,14 @@ class FileRepository @Inject constructor( val category = computeCategory(input.mimeType, input.extension).dbValue + // Garde anti-résurrection (C4) : un `delete_resource` déjà journalisé + // (ordre journal-first) interdit de réimporter la ressource — le + // serveur s'apprête à la supprimer et la repasse physique va suivre. + if (existing != null && outboxRepository.hasPendingDeleteOperation(existing.resourceId)) { + if (existing.exists != 0) fileDao.markMissing(existing.resourceId, now) + return existing.copy(exists = 0, updatedAt = now) + } + // Un `move_resource` encore en attente fait de la cible outbox la // source de vérité du placement : un snapshot SAF périmé (walk lancé // avant le move) ne doit pas ré-attribuer le dossier à l'ancien parent. diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FolderRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FolderRepository.kt index 0489ecf..f9100c1 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FolderRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FolderRepository.kt @@ -114,6 +114,12 @@ class FolderRepository @Inject constructor( val existing = input.resourceId?.let { folderDao.getByResourceId(it) } ?: input.uri?.let { folderDao.getByUri(it) } + // Garde anti-résurrection (C4) : voir `FileRepository.saveLocalFile`. + if (existing != null && outboxRepository.hasPendingDeleteOperation(existing.resourceId)) { + if (existing.exists != 0) folderDao.markMissing(existing.resourceId, now) + return existing.copy(exists = 0, updatedAt = now) + } + // Garde pending-move (M1) : un snapshot SAF périmé ne revert jamais un // reparent/merge en cours de push. val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId) diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt index 4fbe344..8980cf3 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt @@ -58,6 +58,9 @@ class OutboxRepository @Inject constructor( resourceType = resourceType, operation = operation, payload = payloadAdapter.toJson(payload), + // Lien parent→enfant dénormalisé pour la cascade (P8) — + // même clé que le payload JSON ci-dessous. + parentResourceId = payload[PARENT_PAYLOAD_KEY] as? String, status = PendingOpStatus.PENDING, createdAt = now, updatedAt = now, @@ -163,6 +166,27 @@ class OutboxRepository @Inject constructor( suspend fun hasCreateOperationAnyType(resourceId: String): Boolean = pendingOperationDao.countCreateOperationsAnyType(resourceId) > 0 + /** + * Le serveur connaît-il déjà ce fichier (create `synced`) ? Gate delete + * précis (M19) : après [cancelPendingCreates], un `delete_resource` n'est + * émis que dans ce cas — jamais pour une ressource que le serveur n'a + * jamais vue (ni bruit create-puis-delete, ni `NOT_FOUND`). + */ + suspend fun hasSyncedCreateOperation(resourceId: String): Boolean = + pendingOperationDao.countSyncedCreateOperations(resourceId) > 0 + + /** Variante dossiers de [hasSyncedCreateOperation]. */ + suspend fun hasSyncedCreateOperationAnyType(resourceId: String): Boolean = + pendingOperationDao.countSyncedCreateOperationsAnyType(resourceId) > 0 + + /** + * Annulation (M19) : supprime les `create_resource` encore `pending` pour + * cette ressource qui disparaît localement avant que le serveur l'ait + * connue. Retourne le nombre d'ops annulées. + */ + suspend fun cancelPendingCreates(resourceId: String): Int = + pendingOperationDao.deletePendingCreates(resourceId) + /** * Un `move_resource` est-il encore en attente de push ? Tant que l'op est * pendante, le `folder_resource_id` local reflète la cible future : ni le @@ -172,6 +196,23 @@ class OutboxRepository @Inject constructor( suspend fun hasPendingMoveOperation(resourceId: String): Boolean = pendingOperationDao.countPendingMoveOperations(resourceId) > 0 + /** + * Un `delete_resource` est-il encore en attente de push ? Garde + * anti-résurrection du walk (C4, voir DAO) : une ressource dont la + * suppression est journalisée ne doit plus être réimportée. + */ + suspend fun hasPendingDeleteOperation(resourceId: String): Boolean = + pendingOperationDao.countPendingDeleteOperations(resourceId) > 0 + + companion object { + /** + * Clé du lien parent→enfant, à la fois dans le payload JSON + * `create_resource` (protocole, lu par `OutboxSyncWorker`) et dans la + * colonne dénormalisée `parent_resource_id` (cascade SQL). + */ + const val PARENT_PAYLOAD_KEY = "parentResourceId" + } + /** * Un `move_resource` (pending ou synced) a-t-il jamais été journalisé ? * Utilisé par la réconciliation du walk : une ligne en transition physique diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FileDeleter.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FileDeleter.kt index 27d980b..98c8501 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FileDeleter.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FileDeleter.kt @@ -88,7 +88,11 @@ class FileDeleter @Inject constructor( private suspend fun deleteInCloud(file: FileEntity): Boolean { var ok = false runCatching { - if (outboxRepository.hasCreateOperation(file.resourceId)) { + // Jamais poussé (create encore pending) : annulation (M19), pas + // de delete — le serveur n'a rien à oublier. Poussé (synced) : + // `delete_resource`, le serveur connaît la ressource. + outboxRepository.cancelPendingCreates(file.resourceId) + if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) { outboxRepository.enqueueDeleteResource(file.resourceId, "file") } ok = true @@ -100,34 +104,75 @@ class FileDeleter @Inject constructor( } /** - * Suppression complète : physique + cloud. - * Transaction atomique : SAF delete + markMissing + outbox. + * Suppression complète : journal d'abord, physique ensuite (C4). + * + * Ordre crash-safe : la transaction Room (`exists = 0` + annulation du + * create pending + éventuel `delete_resource`) est committée AVANT la + * suppression SAF — un kill entre les deux ne perd plus le journal, le + * serveur est toujours notifié. Si la suppression physique échoue (ou si + * le kill survient juste après), la ligne reste `exists = 0` avec son + * `uri` : la repasse [sweepPendingPhysicalDeletes] retentera le + * `deleteDocument` au prochain tick (le walk peut la ressusciter + * entre-temps, elle sera re-marquée sans nouveau journal — convergence). */ private suspend fun deleteFull(file: FileEntity): Boolean { val uri = file.uri return if (uri != null) { - runCatching { - DocumentsContract.deleteDocument(resolver, Uri.parse(uri)) - }.onSuccess { deleted -> - if (deleted) { - val now = System.currentTimeMillis() - appDatabase.withTransaction { - fileRepository.markMissing(file.resourceId, now) - if (outboxRepository.hasCreateOperation(file.resourceId)) { - outboxRepository.enqueueDeleteResource(file.resourceId, "file") - } - } - Timber.d("deleted full %s", uri) - thumbnailStore.delete(file.resourceId) - } else { - Timber.w("deleteDocument returned false for %s", uri) + val now = System.currentTimeMillis() + appDatabase.withTransaction { + fileRepository.markMissing(file.resourceId, now) + outboxRepository.cancelPendingCreates(file.resourceId) + if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) { + outboxRepository.enqueueDeleteResource(file.resourceId, "file") } + } + val deleted = runCatching { + DocumentsContract.deleteDocument(resolver, Uri.parse(uri)) }.onFailure { e -> - Timber.w(e, "deleteDocument failed for %s", uri) + Timber.w(e, "deleteDocument failed for %s (sweep will retry)", uri) }.getOrDefault(false) + if (deleted) { + Timber.d("deleted full %s", uri) + thumbnailStore.delete(file.resourceId) + } else { + Timber.w("deleteDocument returned false for %s (sweep will retry)", uri) + } + deleted } else { // Cloud-only : outbox uniquement. deleteInCloud(file) } } + + /** + * Repasse C4 : retente la suppression physique des lignes déjà + * journalisées (`exists = 0`, `uri` présente) dont les octets ont survécu + * (kill entre journal et SAF, refus du provider). Bornée ([SWEEP_LIMIT]) + * et best-effort — appelée à chaque tick de sync et après chaque import. + * Retourne le nombre d'octets effectivement supprimés. + */ + suspend fun sweepPendingPhysicalDeletes(limit: Int = SWEEP_LIMIT): Int { + var swept = 0 + val stale = try { + appDatabase.fileDao().getMissingWithUri(limit) + } catch (e: Exception) { + Timber.w(e, "sweep: lecture impossible") + return 0 + } + for (file in stale) { + val uri = file.uri ?: continue + val deleted = runCatching { + DocumentsContract.deleteDocument(resolver, Uri.parse(uri)) + }.getOrDefault(false) + if (deleted) { + thumbnailStore.delete(file.resourceId) + swept++ + } + } + return swept + } + + companion object { + private const val SWEEP_LIMIT = 50 + } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderDeleter.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderDeleter.kt index cb7f11f..423f5e3 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderDeleter.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderDeleter.kt @@ -91,7 +91,8 @@ class FolderDeleter @Inject constructor( private suspend fun deleteInCloud(folder: FolderEntity): Boolean { var ok = false runCatching { - if (outboxRepository.hasCreateOperationAnyType(folder.resourceId)) { + outboxRepository.cancelPendingCreates(folder.resourceId) + if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) { outboxRepository.enqueueDeleteResource(folder.resourceId, "folder") } ok = true @@ -102,43 +103,88 @@ class FolderDeleter @Inject constructor( return ok } - /** Suppression complète : physique + cloud. Transaction atomique Room. */ + /** + * Suppression complète : journal d'abord, physique ensuite (C4). + * + * Même contrat crash-safe que `FileDeleter.deleteFull` : la transaction + * Room (`exists = 0` sur tout l'arbre + annulation des creates pending + + * `delete_resource` là où le serveur connaît déjà la ressource) est + * committée AVANT la suppression SAF. Un kill entre les deux ne perd plus + * le journal ; si le physique échoue, [sweepPendingPhysicalDeletes] + * retentera au prochain tick (le walk ne ressuscite plus les lignes sous + * `delete_resource` pending — garde anti-résurrection). + */ private suspend fun deleteFull(folder: FolderEntity): Boolean { val uri = folder.uri if (uri != null) { val tree = collectDescendants(folder.resourceId) - if (deleteTreePhysically(folder, tree)) { - val now = System.currentTimeMillis() - appDatabase.withTransaction { - treeMarkMissing(folder, tree, now) - } + val now = System.currentTimeMillis() + appDatabase.withTransaction { + treeMarkMissing(folder, tree, now) + } + return if (deleteTreePhysically(folder, tree)) { tree.files.forEach { thumbnailStore.delete(it.resourceId) } Timber.d("deleted folder full %s", uri) - return true + true + } else { + Timber.w("deleteDocument returned false for %s (sweep will retry)", uri) + false } - Timber.w("deleteDocument returned false for %s", uri) - return false } // Cloud-only : outbox uniquement. return deleteInCloud(folder) } + /** + * Repasse C4 (dossiers) : retente la suppression physique des arbres déjà + * journalisés (`exists = 0`, `uri` présente). Un dossier n'est retenté que + * si toute sa descendance Room est aussi `exists = 0` — jamais de + * suppression d'un arbre encore vivant. Bornée ([SWEEP_LIMIT]). + * Retourne le nombre d'arbres effectivement supprimés. + */ + suspend fun sweepPendingPhysicalDeletes(limit: Int = SWEEP_LIMIT): Int { + var swept = 0 + val stale = try { + appDatabase.folderDao().getMissingWithUri(limit) + } catch (e: Exception) { + Timber.w(e, "sweep folders: lecture impossible") + return 0 + } + for (folder in stale) { + val tree = collectDescendants(folder.resourceId) + val alive = tree.files.any { it.exists != 0 } || tree.folders.any { it.exists != 0 } + if (alive) continue + if (deleteTreePhysically(folder, tree)) { + tree.files.forEach { thumbnailStore.delete(it.resourceId) } + swept++ + } + } + return swept + } + + companion object { + private const val SWEEP_LIMIT = 50 + } + /** Marque missing + outbox `delete_resource` pour toute la descendance, atomique. */ private suspend fun treeMarkMissing(folder: FolderEntity, tree: FolderTree, now: Long) { for (file in tree.files) { fileRepository.markMissing(file.resourceId, now) - if (outboxRepository.hasCreateOperation(file.resourceId)) { + outboxRepository.cancelPendingCreates(file.resourceId) + if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) { outboxRepository.enqueueDeleteResource(file.resourceId, "file") } } for (desc in tree.folders) { folderRepository.markMissing(desc.resourceId, now) - if (outboxRepository.hasCreateOperationAnyType(desc.resourceId)) { + outboxRepository.cancelPendingCreates(desc.resourceId) + if (outboxRepository.hasSyncedCreateOperationAnyType(desc.resourceId)) { outboxRepository.enqueueDeleteResource(desc.resourceId, "folder") } } folderRepository.markMissing(folder.resourceId, now) - if (outboxRepository.hasCreateOperationAnyType(folder.resourceId)) { + outboxRepository.cancelPendingCreates(folder.resourceId) + if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) { outboxRepository.enqueueDeleteResource(folder.resourceId, "folder") } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/SafFileDeleter.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/SafFileDeleter.kt index fbd458d..a2a1a49 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/SafFileDeleter.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/SafFileDeleter.kt @@ -41,32 +41,39 @@ class SafFileDeleter @Inject constructor( private val resolver: ContentResolver get() = context.contentResolver + /** + * Suppression review (swipe ✗) : journal d'abord, physique ensuite (C4 — + * même contrat que `FileDeleter.deleteFull`, la repasse + * `FileDeleter.sweepPendingPhysicalDeletes` couvrant aussi ces lignes). + */ suspend fun delete(file: FileEntity): Boolean { val uri = file.uri ?: return false return withContext(Dispatchers.IO) { - runCatching { - DocumentsContract.deleteDocument(resolver, Uri.parse(uri)) - }.onSuccess { deleted -> - if (deleted) { - val now = System.currentTimeMillis() - appDatabase.withTransaction { - fileRepository.markMissing(file.resourceId, now) - // Gate « processed » : si le fichier n'a jamais été poussé - // (create_resource absent), le serveur n'en sait rien — - // un delete_resource serait du bruit. On ne le journalise - // que pour les ressources déjà synchronisées. - if (outboxRepository.hasCreateOperation(file.resourceId)) { - outboxRepository.enqueueDeleteResource(file.resourceId, "file") - } - } - Timber.d("deleted %s", uri) - thumbnailStore.delete(file.resourceId) - } else { - Timber.w("deleteDocument returned false for %s", uri) + val now = System.currentTimeMillis() + appDatabase.withTransaction { + fileRepository.markMissing(file.resourceId, now) + // Gate « processed » + annulation (M19) : si le fichier + // n'a jamais été poussé (create encore pending), on + // annule le create au lieu d'un delete bruit ; le + // delete n'est journalisé que si le serveur connaît + // déjà la ressource (create synced). + outboxRepository.cancelPendingCreates(file.resourceId) + if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) { + outboxRepository.enqueueDeleteResource(file.resourceId, "file") } + } + val deleted = runCatching { + DocumentsContract.deleteDocument(resolver, Uri.parse(uri)) }.onFailure { e -> - Timber.w(e, "deleteDocument failed for %s", uri) + Timber.w(e, "deleteDocument failed for %s (sweep will retry)", uri) }.getOrDefault(false) + if (deleted) { + Timber.d("deleted %s", uri) + thumbnailStore.delete(file.resourceId) + } else { + Timber.w("deleteDocument returned false for %s (sweep will retry)", uri) + } + deleted } } } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/DeviceSync.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/DeviceSync.kt index 92a1f6c..d236776 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/DeviceSync.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/DeviceSync.kt @@ -130,21 +130,30 @@ class DeviceSync @Inject constructor( val now = System.currentTimeMillis() for (folder in folderRepository.getAll()) { val folderUri = folder.uri - if (folder.exists != 0 && folderUri != null && isChildOf(folderUri, rootUri) && folderUri !in seen) { + if (folder.exists != 0 && folderUri != null && isChildOf(folderUri, rootUri) && folderUri !in seen && + !outboxRepository.hasPendingMoveOperation(folder.resourceId) + ) { folderRepository.markMissing(folder.resourceId, now) + // Disparu avant push : annule le create pending (M19) — + // le serveur ne doit ni le créer ni l'oublier. + outboxRepository.cancelPendingCreates(folder.resourceId) missing++ } } for (file in fileRepository.getAll()) { val fileUri = file.uri - // Un `move_resource` (pending ou synced) fait de l'outbox la + // Un `move_resource` encore `pending` fait de l'outbox la // source de vérité du placement : on ne masque jamais une ligne // en transition vers une autre arborescence physique (le // snapshot peut être périmé par rapport au move en cours). + // Un move déjà `synced` ne protège plus : si le fichier a + // ensuite disparu du disque, c'est une vraie suppression + // (sinon fantôme `exists = 1` éternel, M4). if (file.exists != 0 && fileUri != null && isChildOf(fileUri, rootUri) && fileUri !in seen && - !outboxRepository.hasMoveOperation(file.resourceId) + !outboxRepository.hasPendingMoveOperation(file.resourceId) ) { fileRepository.markMissing(file.resourceId, now) + outboxRepository.cancelPendingCreates(file.resourceId) missing++ } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/OutboxSyncWorker.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/OutboxSyncWorker.kt index b61f471..f21cf16 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/OutboxSyncWorker.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/OutboxSyncWorker.kt @@ -23,6 +23,7 @@ import com.kazier.mobile.data.local.entity.PendingOperationType import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiException import com.kazier.mobile.data.remote.dto.SyncOpDto +import com.kazier.mobile.data.repository.OutboxRepository import com.kazier.mobile.features.ocr.OcrAutoWorker import dagger.assisted.Assisted import dagger.assisted.AssistedInject @@ -267,10 +268,10 @@ class OutboxSyncWorker @AssistedInject constructor( } } - /** Lien parent→enfant porté par le payload (`create_resource` avec parent). */ + /** Lien parent→enfant : colonne dénormalisée, repli parsing JSON (lignes pré-v14). */ private fun parentResourceIdOf(op: PendingOperationEntity): String? = - runCatching { payloadAdapter.fromJson(op.payload) } - .getOrNull()?.get(PARENT_RESOURCE_ID_KEY) as? String + op.parentResourceId ?: runCatching { payloadAdapter.fromJson(op.payload) } + .getOrNull()?.get(OutboxRepository.PARENT_PAYLOAD_KEY) as? String companion object { const val NAME = "outbox_sync" @@ -278,8 +279,6 @@ class OutboxSyncWorker @AssistedInject constructor( private const val PURGE_AGE_MS = 7 * 24 * 60 * 60 * 1000L /** Fenêtre de balayage de la cascade (au-delà, convergence au run suivant). */ private const val CASCADE_SCAN_LIMIT = 10_000 - /** Clé du lien parent→enfant dans le payload `create_resource`. */ - private const val PARENT_RESOURCE_ID_KEY = "parentResourceId" /** * Enregistre (idempotent) le worker avec contrainte réseau + backoff. diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt index d455257..caf7337 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt @@ -12,6 +12,8 @@ import com.kazier.mobile.data.repository.FolderRepository import com.kazier.mobile.data.repository.SaveFolderInput import com.kazier.mobile.data.repository.ShareRepository import com.kazier.mobile.features.ocr.OcrAutoWorker +import com.kazier.mobile.features.saf.FileDeleter +import com.kazier.mobile.features.saf.FolderDeleter import dagger.hilt.android.lifecycle.HiltViewModel import dagger.hilt.android.qualifiers.ApplicationContext import kotlinx.coroutines.CancellationException @@ -49,6 +51,8 @@ class SyncViewModel @Inject constructor( private val folderRepository: FolderRepository, private val pendingOperationDao: PendingOperationDao, private val shareRepository: ShareRepository, + private val fileDeleter: FileDeleter, + private val folderDeleter: FolderDeleter, @ApplicationContext private val appContext: Context, ) : ViewModel() { @@ -110,6 +114,16 @@ class SyncViewModel @Inject constructor( OutboxSyncWorker.enqueue(appContext) // OCR auto : uploader les octets des fichiers récemment promus (local-cloud). OcrAutoWorker.enqueue(appContext) + // Repasse C4 : les suppressions journalisées dont les + // octets ont survécu (crash entre journal et SAF). + runCatching { + fileDeleter.sweepPendingPhysicalDeletes() + + folderDeleter.sweepPendingPhysicalDeletes() + }.onSuccess { swept -> + if (swept > 0) Timber.d("sweep: %d suppressions physiques rattrapées", swept) + }.onFailure { e -> + Timber.w(e, "sweep failed, retrying later") + } } .onFailure { e -> Timber.w(e, "syncAll failed, retrying later") } // Hydrate les ressources partagées depuis le snapshot serveur. @@ -143,6 +157,14 @@ class SyncViewModel @Inject constructor( ) val result = deviceSync.syncRoot(saved.resourceId) Timber.d("syncRoot %s", result) + // Même drain qu'après `syncAll` (M7) : le `create_resource` de + // la racine ne doit pas dormir jusqu'au prochain tick. + OutboxSyncWorker.enqueue(appContext) + OcrAutoWorker.enqueue(appContext) + runCatching { + fileDeleter.sweepPendingPhysicalDeletes() + + folderDeleter.sweepPendingPhysicalDeletes() + }.onFailure { e -> Timber.w(e, "sweep failed, retrying later") } } catch (e: CancellationException) { throw e } catch (e: Exception) { diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderdetail/FolderDetailViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderdetail/FolderDetailViewModel.kt index 499a484..740e472 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderdetail/FolderDetailViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderdetail/FolderDetailViewModel.kt @@ -11,7 +11,7 @@ import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.repository.FileRepository import com.kazier.mobile.data.repository.FolderRepository import com.kazier.mobile.data.repository.SaveFolderInput -import com.kazier.mobile.domain.DeviceIdentity +import com.kazier.mobile.domain.ActiveUserStore import com.kazier.mobile.features.saf.FileDeleter import com.kazier.mobile.features.saf.FileMover import com.kazier.mobile.features.saf.SafFolderCreator @@ -54,7 +54,7 @@ class FolderDetailViewModel @Inject constructor( private val safFolderCreator: SafFolderCreator, private val fileMover: FileMover, private val fileDeleter: FileDeleter, - private val deviceIdentity: DeviceIdentity, + private val activeUserStore: ActiveUserStore, @ApplicationContext private val context: Context, ) : ViewModel() { @@ -156,7 +156,7 @@ class FolderDetailViewModel @Inject constructor( val folder = _uiState.value.folder val shareable = folder != null && tokenProvider.current != null && - (folder.ownerId == null || folder.ownerId == deviceIdentity.getOrCreate()) + (folder.ownerId == null || folder.ownerId == activeUserStore.get()) _uiState.update { it.copy(canShare = shareable) } } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderlist/FolderListViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderlist/FolderListViewModel.kt index cd639e7..b0ad8b3 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderlist/FolderListViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderlist/FolderListViewModel.kt @@ -15,7 +15,7 @@ import com.kazier.mobile.data.remote.ApiException import com.kazier.mobile.data.repository.FileRepository import com.kazier.mobile.data.repository.FolderRepository import com.kazier.mobile.data.repository.SaveFolderInput -import com.kazier.mobile.domain.DeviceIdentity +import com.kazier.mobile.domain.ActiveUserStore import com.kazier.mobile.features.saf.FileMover import com.kazier.mobile.features.saf.FileDeleter import com.kazier.mobile.features.saf.FolderDeleter @@ -49,7 +49,7 @@ class FolderListViewModel @Inject constructor( private val fileMover: FileMover, private val fileDeleter: FileDeleter, private val folderDeleter: FolderDeleter, - private val deviceIdentity: DeviceIdentity, + private val activeUserStore: ActiveUserStore, @ApplicationContext private val context: Context, ) : ViewModel() { @@ -191,7 +191,8 @@ class FolderListViewModel @Inject constructor( /** * Un dossier est partageable quand l'utilisateur est connecté et que ce * n'est pas une ressource reçue en partage : `ownerId` absent ou égal à - * l'identité du device (les lignes hydratées portent l'utilisateur réel). + * l'utilisateur connecté (`owner_id` Room = `user_id`, jamais le device — + * les lignes hydratées du snapshot portent le vrai propriétaire). * * Pas de gate `syncStatus` : un dossier `local` a son `create_resource` * enqueued avant le `share` dans le même outbox — le serveur applique la @@ -199,8 +200,8 @@ class FolderListViewModel @Inject constructor( */ private suspend fun isShareable(folder: FolderEntity): Boolean { if (tokenProvider.current == null) return false - val deviceUserId = deviceIdentity.getOrCreate() - return folder.ownerId == null || folder.ownerId == deviceUserId + val currentUserId = activeUserStore.get() + return folder.ownerId == null || folder.ownerId == currentUserId } suspend fun isShareableFolder(folder: FolderEntity): Boolean = isShareable(folder) @@ -288,7 +289,7 @@ class FolderListViewModel @Inject constructor( title = trimmed, body = body, folderResourceId = targetId, - ownerId = deviceIdentity.getOrCreate(), + ownerId = activeUserStore.get(), ) }.onFailure { _uiState.update { it.copy(createError = context.getString(R.string.new_folder_error)) } diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/ParentLinkCascadeTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/ParentLinkCascadeTest.kt new file mode 100644 index 0000000..4e2d747 --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/ParentLinkCascadeTest.kt @@ -0,0 +1,124 @@ +package com.kazier.mobile.data.local.dao + +import android.content.Context +import androidx.room.Room +import androidx.test.core.app.ApplicationProvider +import com.squareup.moshi.Moshi +import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory +import com.kazier.mobile.data.local.AppDatabase +import com.kazier.mobile.data.local.entity.PendingOpStatus +import com.kazier.mobile.data.local.entity.PendingOperationEntity +import com.kazier.mobile.data.local.entity.PendingOperationType +import com.kazier.mobile.data.repository.OutboxRepository +import com.kazier.mobile.domain.DeviceIdentity +import com.kazier.mobile.domain.GenerateId +import kotlinx.coroutines.test.runTest +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** + * P8 : le lien parent→enfant de la cascade est dénormalisé en colonne + * `parent_resource_id` (robuste au format Moshi), avec repli `LIKE` sur le + * payload pour les lignes pré-v14. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class ParentLinkCascadeTest { + + private lateinit var db: AppDatabase + private lateinit var opsDao: PendingOperationDao + private lateinit var outboxRepository: OutboxRepository + + @Before + fun setUp() { + val context = ApplicationProvider.getApplicationContext() + db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java) + .allowMainThreadQueries() + .build() + opsDao = db.pendingOperationDao() + val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build() + val generateId = GenerateId() + outboxRepository = OutboxRepository( + opsDao, + generateId, + DeviceIdentity(db.userPreferenceDao(), generateId), + moshi, + ) + } + + @After + fun tearDown() { + db.close() + } + + @Test + fun enqueue_remplit_la_colonne_parent() = runTest { + outboxRepository.enqueueCreateResource( + resourceId = CHILD, + resourceType = "folder", + name = "Enfant", + parentResourceId = PARENT, + ) + + val rows = opsDao.selectPending(10).filter { it.resourceId == CHILD } + assertEquals(1, rows.size) + assertEquals("la colonne dénormalisée porte le parent", PARENT, rows[0].parentResourceId) + } + + @Test + fun cascade_via_colonne_sans_lien_json() = runTest { + // Payload volontairement vide : seul `parent_resource_id` lie l'enfant. + opsDao.insert( + op(resourceId = CHILD, parentResourceId = PARENT, payload = "{}"), + ) + + opsDao.failDescendants(PARENT, NOW) + + // La ligne est passée `failed` : elle n'est plus `pending`. + assertEquals(0, opsDao.countByStatus(PendingOpStatus.PENDING)) + assertEquals( + "l'enfant est invalidé par la colonne, sans parsing JSON", + 1, + opsDao.countByStatus(PendingOpStatus.FAILED), + ) + } + + @Test + fun repli_like_pour_lignes_pre_v14_sans_colonne() = runTest { + opsDao.insert( + op( + resourceId = CHILD, + parentResourceId = null, + payload = """{"name":"Enfant","parentResourceId":"$PARENT"}""", + ), + ) + + opsDao.failDescendants(PARENT, NOW) + + assertEquals(1, opsDao.countByStatus(PendingOpStatus.FAILED)) + } + + private fun op(resourceId: String, parentResourceId: String?, payload: String) = + PendingOperationEntity( + operationId = resourceId, + resourceId = resourceId, + resourceType = "folder", + operation = PendingOperationType.CREATE_RESOURCE, + payload = payload, + parentResourceId = parentResourceId, + status = PendingOpStatus.PENDING, + createdAt = NOW, + updatedAt = NOW, + ) + + private companion object { + const val NOW = 1_700_000_000_000L + const val PARENT = "11111111111111111111111111111111" + const val CHILD = "22222222222222222222222222222222" + } +} diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration13To14Test.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration13To14Test.kt new file mode 100644 index 0000000..571e1ce --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration13To14Test.kt @@ -0,0 +1,102 @@ +package com.kazier.mobile.data.local.migration + +import android.content.Context +import androidx.sqlite.db.SupportSQLiteDatabase +import androidx.sqlite.db.SupportSQLiteOpenHelper +import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory +import androidx.test.core.app.ApplicationProvider +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** + * P8 : la migration 13→14 ajoute `parent_resource_id` + son index sans + * toucher aux lignes existantes (NULL → repli LIKE). Une coquille SQL ici + * briquerait l'app au démarrage après update : on rejoue la migration sur + * une table v13 minimale et on vérifie schéma + données. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class Migration13To14Test { + + @Test + fun migration_ajoute_la_colonne_et_l_index_en_preservant_les_lignes() { + val context = ApplicationProvider.getApplicationContext() + val helper = FrameworkSQLiteOpenHelperFactory().create( + SupportSQLiteOpenHelper.Configuration.builder(context) + .name(null) + .callback(V13Callback()) + .build(), + ) + val db = helper.writableDatabase + db.execSQL( + "INSERT INTO `pending_operations` " + + "(`device_id`, `operation_id`, `resource_id`, `operation`, `payload`, `status`, `created_at`, `updated_at`) " + + "VALUES ('d1', 'op1', 'r1', 'create_resource', '{\"a\":1}', 'pending', 1, 1)", + ) + + val migration = Migrations.ALL.first { it.startVersion == 13 && it.endVersion == 14 } + migration.migrate(db) + + // Colonne présente et NULL sur les lignes préexistantes. + val columns = mutableListOf() + db.query("PRAGMA table_info(`pending_operations`)").use { cursor -> + val nameIdx = cursor.getColumnIndexOrThrow("name") + while (cursor.moveToNext()) columns += cursor.getString(nameIdx) + } + assertTrue(columns.contains("parent_resource_id")) + db.query("SELECT `parent_resource_id` FROM `pending_operations`").use { cursor -> + assertTrue(cursor.moveToFirst()) + assertTrue(cursor.isNull(0)) + } + // Index présent. + var indexFound = false + db.query("PRAGMA index_list(`pending_operations`)").use { cursor -> + val nameIdx = cursor.getColumnIndexOrThrow("name") + while (cursor.moveToNext()) { + if (cursor.getString(nameIdx) == "index_pending_operations_parent_resource_id") { + indexFound = true + } + } + } + assertTrue("index parent_resource_id manquant", indexFound) + // Données intactes. + db.query("SELECT `operation_id`, `status` FROM `pending_operations`").use { cursor -> + assertTrue(cursor.moveToFirst()) + assertEquals("op1", cursor.getString(0)) + assertEquals("pending", cursor.getString(1)) + } + helper.close() + } + + /** Schéma v13 minimal de `pending_operations` (sans `parent_resource_id`). */ + private class V13Callback : SupportSQLiteOpenHelper.Callback(13) { + override fun onCreate(db: SupportSQLiteDatabase) { + db.execSQL( + "CREATE TABLE `pending_operations` (" + + "`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " + + "`device_id` TEXT, " + + "`operation_id` TEXT NOT NULL, " + + "`ref_type` TEXT, " + + "`ref_id` INTEGER, " + + "`resource_id` TEXT, " + + "`resource_type` TEXT, " + + "`operation` TEXT NOT NULL, " + + "`payload` TEXT NOT NULL, " + + "`status` TEXT NOT NULL, " + + "`attempts` INTEGER NOT NULL DEFAULT 0, " + + "`created_at` INTEGER NOT NULL, " + + "`updated_at` INTEGER NOT NULL)", + ) + } + + override fun onUpgrade( + db: SupportSQLiteDatabase, + oldVersion: Int, + newVersion: Int, + ) = Unit + } +} diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt index bd1038b..8e4306e 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt @@ -9,6 +9,8 @@ import com.kazier.mobile.auth.SessionManager import com.kazier.mobile.auth.TokenProvider import com.kazier.mobile.auth.TokenStore import com.kazier.mobile.data.local.AppDatabase +import com.kazier.mobile.data.local.entity.PendingOpStatus +import com.kazier.mobile.data.local.entity.PendingOperationType import com.kazier.mobile.data.remote.dto.ApiEnvelope import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto @@ -78,6 +80,7 @@ class Auth401Test { ActiveUserStore(db.userPreferenceDao()), tokenProvider, LocalModeStore(db.userPreferenceDao()), + db.pendingOperationDao(), apiClient, ) } @@ -129,8 +132,7 @@ class Auth401Test { } @Test - fun `401_login_ne_purge_pas`() = runBlocking { - seed() + fun `401_login_ne_purge_pas`() = runBlocking { seed() val error = runCatching { apiClient.login("alice", "mauvais-mdp", "device-1") }.exceptionOrNull() assertNotNull(error) assertEquals("UNAUTHORIZED", (error as ApiException).code) @@ -139,6 +141,69 @@ class Auth401Test { assertEquals("tok-abc", tokenStore.getToken()) } + // --- C5 : pas de replay cross-account ------------------------------------ + + @Test + fun `signOut_purge_pending_et_failed_conserve_synced`() = runBlocking { + seed() + val ops = db.pendingOperationDao() + ops.insert(op("a", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.PENDING)) + ops.insert(op("b", PendingOperationType.MOVE_RESOURCE, PendingOpStatus.FAILED)) + ops.insert(op("c", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.SYNCED)) + + sessionManager.clear() + + assertNull(tokenProvider.current) + assertEquals("pending purgé", 0, ops.countByStatus(PendingOpStatus.PENDING)) + assertEquals("failed purgé", 0, ops.countByStatus(PendingOpStatus.FAILED)) + assertEquals("les tombstones synced survivent", 1, ops.countByStatus(PendingOpStatus.SYNCED)) + } + + @Test + fun `login_autre_compte_purge_la_file`() = runBlocking { + sessionManager.save("tok-a", UserDto(id = "user-a", username = "alice"), null) + val ops = db.pendingOperationDao() + ops.insert(op("a", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.PENDING)) + + sessionManager.save("tok-b", UserDto(id = "user-b", username = "bob"), null) + + assertEquals("la file de A ne part pas sous le token de B", 0, ops.countPending()) + assertEquals("user-b", ActiveUserStore(db.userPreferenceDao()).get()) + } + + @Test + fun `relogin_meme_compte_conserve_la_file`() = runBlocking { + sessionManager.save("tok-a1", UserDto(id = "user-a", username = "alice"), null) + val ops = db.pendingOperationDao() + ops.insert(op("a", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.PENDING)) + + sessionManager.save("tok-a2", UserDto(id = "user-a", username = "alice"), null) + + assertEquals("un simple renouvellement de token ne perd rien", 1, ops.countPending()) + } + + @Test + fun `premier_login_conserve_le_travail_local`() = runBlocking { + val ops = db.pendingOperationDao() + ops.insert(op("a", PendingOperationType.CREATE_RESOURCE, PendingOpStatus.PENDING)) + + sessionManager.save("tok-a", UserDto(id = "user-a", username = "alice"), null) + + assertEquals("le travail du mode local est poussé après login", 1, ops.countPending()) + } + + private fun op(resourceId: String, operation: String, status: String) = + com.kazier.mobile.data.local.entity.PendingOperationEntity( + operationId = resourceId, + resourceId = "r".repeat(32), + resourceType = "file", + operation = operation, + payload = "{}", + status = status, + createdAt = 1L, + updatedAt = 1L, + ) + private class FakeTokenStore : TokenStore { private var token: String? = null private var user: UserDto? = null