diff --git a/FEEDBACK.md b/FEEDBACK.md index 680e56d..9d38dd8 100644 --- a/FEEDBACK.md +++ b/FEEDBACK.md @@ -1,190 +1,146 @@ # FEEDBACK — Audit bugs mobile-kotlin (local-first) > Généré le 2026-09-22 par 5 agents d'exploration parallèles (scopes : Room/DB, sync/outbox/SAF, réseau/auth/repos, UI/navigation/VM, scan/pdf/review/thumbnails). -> Chaque finding est vérifié avec preuve `file:line`. Méthode : lecture intégrale des fichiers + croisement `docs/api-v1.md`, `AGENTS.md`, handlers Go. -> Scope : `mobile-kotlin/` uniquement. Pas de fix appliqué — diagnostic seul. -> Légende : 🔴 Critique (data loss / crash / sync bloquée) · 🟠 Majeur (divergence silencieuse, contrat violé) · 🟡 Mineur (UX, perf, dette). +> Mise à jour le 2026-09-24 : les items corrigés par `d89c0d0 (fix 1 to 6)` et `22286aa (fix mobile audit review)` ont été re-vérifiés code en main et retirés. Ce document ne liste que le **reliquat confirmé**. +> Màj 2026-09-24 (soir) : tout le reliquat ci-dessous est **corrigé et testé** (`:app:testDebugUnitTest` : 162/162 verts, DB v16, schéma `app/schemas/16.json` exporté). Les sections 🟠/🟡/🛠️ sont conservées comme traçabilité. +> Chaque finding restant est vérifié avec preuve `file:line`. +> Scope : `mobile-kotlin/` uniquement. +> Légende : 🟠 Majeur (divergence silencieuse, contrat violé) · 🟡 Mineur (UX, perf, dette). Base paths : `mobile-kotlin/app/src/main/java/com/kazier/mobile/…` --- -## 🔴 Critiques (à corriger en priorité) +## ✅ Corrigés et retirés (vérifiés le 2026-09-24) -### C1 — `domain/GenerateId.kt:19` — IDs 32-hex non conformes (sign-extension `Byte` → `%02x`) -`bytes.joinToString("") { "%02x".format(it) }` promeut chaque `Byte` signé en `int` : tout octet négatif produit `ffffffxx` (8 chars). Longueur 32→128, P(32 exact) ≈ 1/65536. -Impact : `resource_id` / `operation_id` / `device_user_id` violent `^[0-9a-f]{32}$` (CHECK serveur) → `POST /sync/ops` rejetés, outbox bloquée, identités invalides. -Repro : boucler `newResourceId()` et tester `length == 32 && matches([0-9a-f]{32})` → échec quasi systématique. +### 🔴 Critiques : 9/9 corrigés +- **C1** `domain/GenerateId.kt:19` — masque `and 0xFF` contre la sign-extension, 32-hex conforme. +- **C2** `features/sync/OutboxSyncWorker.kt:139-145` — erreurs non-attribuables (`INVALID_RESPONSE`, 429/408, 4xx batch-level) → `Result.retry()` sans toucher aux ops. +- **C3** `data/local/dao/PendingOperationDao.kt:66-72` — `purgeSynced` exclut les `create_resource` (tombstones), gates `countCreateOperations` préservés. +- **C4** `features/saf/FileDeleter.kt:122-128` + `FolderDeleter.kt:122-124` — journal-first (`withTransaction` avant suppression SAF) + `sweepPendingPhysicalDeletes`. +- **C5** `auth/SessionManager.kt:70-77` — `clear()` purge les ops non poussées (`pending`/`failed`), appelé par `AuthViewModel.signOut/signOutToLocal`. +- **C6** `OutboxSyncWorker.kt:185-188` — stop au 1er échec (`return success()`, jamais `continue`) + cascade transitive `cascadeCreateFailure` via `parent_resource_id`/payload. +- **C7** `OutboxSyncWorker.kt:152,170-174,193-196` — `applied.coerceIn`, `failedIndex < 0 → stop`, `applied == 0 → stop` (anti busy-loop/crash). +- **C8** Scan export — `ScanExport.pendingForExport` idempotent, `shouldFinishSession` gate `DONE`, `uniquePageFile()` UUID, `deletePage` DB-d'abord, `exportPdf` ne marque que les succès. +- **C9** `features/scan/ScanImageProcessor.kt:91-92` + `ScanViewModel.kt:213` — jamais de `recycle()` sur l'alias affiché (`!==` check). -### C2 — `features/sync/OutboxSyncWorker.kt:101-106` — dead-letter abusive sur erreurs non-attribuables -Le `else` dead-letter `pending.first()` pour toute `ApiException` non-`NETWORK_ERROR`/5xx/401. `INVALID_RESPONSE` (200 sans enveloppe `{data}`) et `HTTP_429`/`408` (transitoires) tombent dedans. La faute est imputée à la 1re op du batch quelle que soit l'op rejetée. -Impact : op saine → `failed` à vie sur erreur batch-level ou transitoire ; inclut le cas `429 RATE_LIMITED` (login/devices/sync) qui devrait suivre le chemin `retry()`. -Repro : serveur 200 sans `data` ou 429 → 1re op dead-lettrée. +### 🟠 Majeurs corrigés (31) +M1 (garde pending-move dossiers), M2 (gate `create` avant `move`), M3 (`FileMover` sans repli mensonger), M4 (exclusion `exists=0` pending seul), M6 (parent inconnu → `continue`), M7 (`importRoot` schedule le drain), M8 (fichiers 0-octet acceptés), M10 (`DeviceIdentity` mutex + `insertIgnore`), M11 (décision assumée : pas de backfill `create_resource`), M12 (`upsertTolerant` sur `resource_id`/`uri`), M14 (colonne `device_id`, `UNIQUE(device_id, operation_id)` + migration 11→12), M15 (`failDescendants` élargi, cf. C6), M21 (boucle `listFilesPaged` + `meta.total`), M22 (`ApiClient` distingue `CancellationException`/`JsonDataException`/`IOException`), M23 (`activeUserStore` vs `ownerId`, plus de confusion device/user), M24 (`normalizePayloadNumbers` Double→Long), M25 (`SessionManager` possède `onUnauthorized`), M26 (`ServerUrlInterceptor` `runBlocking load()` anti-race), M28 (validation URL `toHttpUrl()`), M29 (`pendingDefaultPick` saveable), M30 (pager `rememberSaveable`), M31 (debounce sur résultats seuls), M32 (gate `canShare` FolderDetail), M33 (`refreshShareGate` au login/logout), M34 (`selection.clear()` + chips figés en sélection), M35 (`resolveViewerPage` clamp), M36 (sélecteur thème 3 états), M37 (flag `dirty` anti-écrasement saisie), M38 (`MAX(sortOrder)+1`), M42 (`processed=true` PDF builder), M43 (réinsertion optimiste review), M44 (`remember(existingIds)` stable). -### C3 — `features/sync/OutboxSyncWorker.kt:83` + `data/local/dao/PendingOperationDao.kt:42-43` — purge >7j qui casse le gate `processed`/`hasCreateOperation` -`purgeSynced` efface les lignes `synced`, or `countCreateOperations` (`IN ('pending','synced')`) fonde les gates delete/create dessus. -Impact : (a) fichier poussé puis purgé → `SafFileDeleter`/`FileDeleter`/`treeMarkMissing` omettent le `delete_resource` → fantôme serveur indélébile ; (b) `markProcessed` ré-enqueue un `create_resource` dupliqué. -Repro : pousser un fichier, attendre 7j, le supprimer → aucun `delete_resource`, serveur garde la ressource. - -### C4 — `features/saf/FolderDeleter.kt:106-124` + `features/saf/FileDeleter.kt:109-119` — suppression physique avant transaction, delete perdu sur crash -`deleteTreePhysically` (SAF, irréversible) avant `withTransaction { treeMarkMissing }`. -Impact : kill/crash entre les deux → octets supprimés, aucun `delete_resource` journalisé, walk suivant marque `exists=0` sans outbox (aucun chemin walk→enqueue) → fantôme serveur + divergence définitive. -Repro : `deleteFull` puis kill avant commit Room → serveur jamais notifié. - -### C5 — `ui/auth/AuthViewModel.kt:112-121` — pas de vidage outbox au sign-out, replay cross-account -`signOut`/`signOutToLocal` purgent session et mode local mais aucune suppression de `pending_operations`. Les ops du compte A survivent au login du compte B (même `device_id`, `UNIQUE(device_id, operation_id)` sans historique partagé). -Impact : ops de A appliquées dans le scope de B (`NOT_FOUND`/`NAME_CONFLICT`, voire créations croisées). -Repro : enqueue offline sous A → sign-out → login B → drain pousse les ops de A sous token B. - -### C6 — `features/sync/OutboxSyncWorker.kt:118-133` — drain poursuivi après échec + cascade limitée au même `resource_id` -Après `markFailed`, `continue` envoie le batch suivant, et `failDescendants` (`PendingOperationDao.kt:38`) ne cible que `resource_id = :resourceId` alors que les enfants portent un autre `resource_id` (lien dans le payload). -Impact : viole « serveur stop à la 1re erreur, client reprend à cet index » — creates enfants poussés et rejetés `NOT_FOUND` un par un, head-of-line blocking + dead-letters en cascade. -Repro : `create` dossier-parent en échec → le run pousse quand même les creates enfants au tour suivant. - -### C7 — `features/sync/OutboxSyncWorker.kt:112-131` — gardes absents sur réponse serveur (boucle infinie / crash) -(a) `result.failed.operationId` absent du batch (`indexOfFirst < 0`) → silence + re-sélection du même batch → boucle serrée sans backoff ; (b) `result.applied > pending.size` → `pending[i]` lève `IndexOutOfBoundsException` → crash worker. -Impact : (a) drain CPU/batterie ; (b) batch jamais acquitté. Complété par `data/remote` : `while(true)` sans garde `applied==0 && failed==null` → busy-loop si serveur renvoie `{applied:0, failed:null}`. -Repro : mocker `syncOps → applied=0, failed=null` ou `operation_id` inconnu → boucle infinie ; `applied` incohérent → crash. - -### C8 — Scan : perte de données à l'export -- `ui/scan/ScanViewModel.kt:387-389` (`exportPdf`) — pages en échec seulement loggées (`failedIds`), puis **toutes** marquées `EXPORTED` + session `DONE` → PDF incomplet, sources abandonnées. -- `ui/scan/ScanViewModel.kt:259-298` (`export`) — retry non idempotent : `getPages` retourne aussi les `EXPORTED`, chaque retry crée un nouvel URI SAF → documents + lignes Room + ops outbox dupliqués. -- `ui/scan/ScanViewModel.kt:263` — fichier temp manquant → page sautée sans marquage mais `finishSession` ferme la session → page `PENDING` dans session `DONE`, jamais reprise ni nettoyée. -- `ui/scan/ScanViewModel.kt:186-201` — nom page `page_$order.jpg` avec `order = pageCount+1` → collision après suppression (A,B → del A → C écrase B) → deux entités même `tempUri`, `deletePage` orpheline B. -Repro : cf. chaque item (export partiel, retry après perte permission SAF, temp supprimé, capture-suppression-capture). - -### C9 — `features/scan/ScanImageProcessor.kt:87-88` + `ui/scan/ScanViewModel.kt:192` — `recycle()` du bitmap encore affiché quand OpenCV indisponible -`process()` retourne l'instance d'entrée si `!isAvailable()` ; l'appelant `recycle()` le `processed` qui alias le draft dessiné par `CropStage` → crash `recycled bitmap`. -Repro : device sans lib OpenCV → valider un crop → crash au retour caméra. +### 🟡 Mineurs corrigés dans `d89c0d0` (voir `git show --stat d89c0d0`) +m4 (gardes cursor SAF), m6 (`deleteLocally` transactionnel), m8 (`FileOrdering` aligné SQL), m9 (commentaire `attempts` diagnostic), m10-m14 (`updateUri`, `LocalModeStore`, `load` réarmable, `StateFlow` après succès DB, clé `SYNC_MODE` retirée), m16-m18 (index, `defaultValue processed`, `swapOrder` contraint), m22 (`ApiService` endpoints contrat ajoutés), m23 (`registerDevice` erreurs visibles), m24 (garde mode local), m25 (logging sans PII), m26 (`Bearer` hors routes publiques), m27 (`expiresAt` persisté), m28 (`SecureTokenStore` lazy + Direct Boot), m29-m31 (nav `pdfbuilder/empty`, `launchSingleTop`, controller hoisté), m33-m39 (side-effects `buildPhase`, dialogs `rememberSaveable`, badge collectes, saisie serveur debouncée, flash thème, bandeau import, `FileStatus.LOCAL`), m40-m56 (scan/camera/thumbnails : résolution bornée, `toBitmap` throttlé, listener retiré, `else` rotation, garde `sourceRect`, arrondi crop, `combine` nettoyé, purge `ABANDONED`, unicité session active, `FileCategory` CSV cohérent, purge map `Mutex`, `.tmp` nettoyés, `isUpToDate` taille+mtime, `runCatching` close, commentaire `max`, `release()` sur exception, deck conservé sur erreur). --- -## 🟠 Majeurs +## 🟠 Majeurs restants (4) — ✅ tous corrigés le 2026-09-24 (162/162 tests verts) -### Sync / Outbox / SAF -- **M1 — `features/sync/DeviceSync.kt:85-91` + `data/repository/FolderRepository.kt:99-134`** : le walk écrase le parent des dossiers sans garde pending-move (`saveFolder` écrase toujours, `reparentSubFolders` métadonnée-seule sans déplacement SAF). Les fichiers ont `hasPendingMoveOperation` (`FileRepository.kt:190`), les dossiers rien → tout reparent/merge revert au tick 30s suivant, divergence disque/serveur permanente. -- **M2 — `data/repository/FileRepository.kt:238-250`** : `applyMove` enqueue `move_resource` sans gate `create` (contrairement aux deletes) → move d'un fichier jamais poussé = `NOT_FOUND`/no-op serveur + ligne figée par `hasPendingMoveOperation`. Même cause `reparentSubFolders` (`FolderRepository.kt:144-157`) pour dossier au `create` purgé (>7j). -- **M3 — `features/saf/FileMover.kt:47-53`** : repli métadonnée-seule incohérent (nouveau parent + ancienne uri quand `moveDocument` refusé) → Room ment durablement, walk bloqué par le garde pending-move, divergence serveur/disque. -- **M4 — `features/sync/DeviceSync.kt:122-134`** : réconciliation `exists=0` asymétrique — fichiers exclus via `hasMoveOperation` (pending **ou** synced → à vie après un move syncé, fichier supprimé ensuite = fantôme `exists=1` éternel) ; dossiers sans exclusion (move en transition marqué `missing` à tort). -- **M5 — `features/saf/FileDeleter.kt:88-100` + `features/saf/FolderDeleter.kt:91-103`** : `deleteInCloud` sans tombstone locale (`exists` reste 1) → ressource toujours affichée, walk la revoit, `refreshFromServer` ne supprime jamais de lignes → fantôme local vs serveur supprimé. -- **M6 — `features/sync/DeviceSync.kt:84`** : `?: root.resourceId` masque toute violation parent-avant-enfant (parent absent de `resourceIdByUri` → enfant rattaché racine) → arbre serveur corrompu silencieusement. -- **M7 — `features/sync/SyncViewModel.kt:135-156`** : `importRoot` ne schedule jamais le drain (contraire `syncAll:110`, login `AuthViewModel:54,77`) → `create_resource` racine dort jusqu'au prochain tick, badge faussement à jour. -- **M8 — `features/sync/SafScanner.kt:146`** : `if (size == 0L) continue` → fichiers vides légitimes exclus du miroir, jamais reviewés ni poussés (perte silencieuse). -- **M9 — `features/saf/FolderMerger.kt:45-85`** : merge multi-transactions non-atomique, non-idempotent (`createMergedFolder` recrée un dossier à chaque appel) → crash à mi-fusion = état partiel poussé, relance = dossier dupliqué côté serveur. - -### Room / DB / Domain -- **M10 — `domain/DeviceIdentity.kt:18-26`** : `getOrCreate()` non atomique (read/insert/re-read hors transaction) + fallback `newResourceId()` jamais persisté → deux identités concurrentes, `owner_id` incohérents, outbox sous identité fantôme (aggravé par C1). -- **M11 — `data/local/migration/Migrations.kt:90-96`** : `MIGRATION_5_6` fait `UPDATE files SET processed = 1` sans `create_resource` rétroactif → backlog jamais poussé, invisible de la review (`getUnprocessed`) et du serveur, à vie. -- **M12 — `data/local/dao/FolderDao.kt:50-54` + `data/local/dao/FileDao.kt:48-49`** : `@Upsert` résout sur PK (`id`) pas sur uniques `resource_id`/`uri` ; pattern read-then-upsert (`id=0`) → deux inserts concurrents même `uri` = `SQLiteConstraintException` (crash walk SAF / refresh serveur). -- **M13 — entités `exists: Int? = null` + filtres `= 1`** (`FolderEntity.kt:36`, `FileEntity.kt:45`, `FolderDao.kt:34,41`, `FileDao.kt:15,18,21,32,42,95,98,108,135`, `Migrations.kt:51-72` sans DEFAULT) : toute ligne sans `exists` explicite disparaît UI/recherche/review — perte fonctionnelle silencieuse. -- **M14 — `data/local/entity/PendingOperationEntity.kt:28-53` + `Migrations.kt:101-123`** : pas de colonne `device_id`, unicité locale sur `operation_id` seul vs contrat `UNIQUE(device_id, operation_id)` → après régénération `device_user_id`, rejeu = `create_resource` dupliqués serveur. -- **M15 — `data/local/dao/PendingOperationDao.kt:38`** : `failDescendants` ne cascade que sur le même `resource_id`, pas les enfants (cf. C6). -- **M16 — `data/local/dao/FileDao.kt:133-145` + `Migrations.kt:75-82`** : `category` ajoutée sans backfill, `getOcrAutoCandidates()` exige `category IN (…)` → tout PDF/image/texte pré-v4 exclu de l'OCR auto à vie. -- **M17 — `data/local/dao/FileDao.kt:151-152`** : `clearOcrQueued` reset `ocr_attempts = 0` inconditionnellement (contredit commentaire `:130-132`) → échec permanent rejoué indéfiniment. -- **M18 — pas de FK `files → folders`** (`FileEntity.kt:18-26`, `FolderEntity.kt:18-25`, `FolderDao.kt:95-96`, `FileDao.kt:92-93` deletes physiques) → `remove(dossier)` laisse orphelins, `moveToFolder` vers parent inexistant accepté, cycles possibles. -- **M19 — `FolderDao.kt:56-57` + `FileDao.kt:51-52`** : `markMissing` = `SET exists = 0` seul (ni `sync_status` ni annulation `create` pending) → ressource disparue quand même poussée (fantôme serveur), placement `local-cloud` mensonger. -- **M20 — `data/local/dao/ScanDao.kt:12-64` + `entity/ScanSessionEntity.kt:15-20`** : sessions `active` multiples possibles (aucun index unique/partiel), aucun `deleteSession` → doubles inserts concurrents = session orpheline + pages fuyantes. - -### Réseau / Auth / Repos -- **M21 — `data/repository/FileRepository.kt:261-272` + `data/remote/ApiClient.kt:64-65`** : pagination jetée (`pageSize=50` sans `page`, `meta` ignoré) alors que le serveur pagine → dossiers > 50 fichiers ne convergent jamais, silencieusement. -- **M22 — `data/remote/ApiClient.kt:119-125`** : `catch (Exception) → NETWORK_ERROR` attrape aussi `JsonDataException` (Moshi) et `InterruptedIOException` (annulation) → parsing cassé = `retry()` infini, coroutine annulée = `ApiException` au lieu de `CancellationException` (scope/WorkManager corrompus). -- **M23 — `data/repository/ShareRepository.kt:45,99-104` + `FolderRepository.kt:115`** : confusion `device_id` vs `user_id` — `syncSnapshot` compare `deviceIdentity.getOrCreate()` (device) à `perm.ownerId` (user serveur), `saveFolder` stocke le device dans `ownerId`, `ActiveUserStore` ignoré. Le snapshot serveur **exclut les ressources possédées** → toute ligne cloud-only au vrai `ownerId=user` est `markMissing` à chaque login/restore (ex. note `createNote(ownerId=userId)` disparaît). -- **M24 — `features/sync/OutboxSyncWorker.kt:159-170` + `data/repository/OutboxRepository.kt:29-31`** : round-trip `expiresAt` Long→Double (Moshi `Map`) → `enqueueShare(expiresAt: Long)` réémis `1.7E12` → serveur `*int64` refuse → `400 INVALID_REQUEST` → **tout partage avec expiration dead-lettered**. -- **M25 — `ui/auth/AuthViewModel.kt:43,123-125`** : callback 401 singleton possédé par un ViewModel (`apiClient.onUnauthorized`, `ApiClient` `@Singleton` survit au VM, annulé dans `onCleared`) → après destruction, 401 ne purge plus la session → token expiré réutilisé, worker `success()` sur 401 fige l'outbox, utilisateur jamais déconnecté. -- **M26 — `domain/ServerConfigStore.kt:32-43` + `data/remote/ServerUrlInterceptor.kt:25-38`** : race `load()` — interceptor lit `current` (défaut `10.0.2.2`) sur thread OkHttp pendant que `load()` restaure l'URL ; `registerDevice()` part avant `load()` → cold start avec URL custom = premières requêtes (y compris `Authorization: Bearer` restauré) vers l'hôte par défaut (**fuite du bearer**). -- **M27 — `data/repository/ShareRepository.kt:44-93` + `data/remote/dto/Dtos.kt:120-132`** : snapshot permissions sans delta (`after` jamais passé), `sharedById`/`expiresAt` en `Any?` jamais lus, `cachedAt` jamais persisté, aucun downgrade 24h ni `canAccess` → grant révoqué/expiré reste visible et ouvrable (`404`) jusqu'au prochain login. -- **M28 — `domain/ServerConfigStore.kt:46-59`** : `set()` persiste URL non validée (`"http://"` → `"http:"`, `"foo bar"` → `"http://foo bar"`) → app semi-brickée jusqu'à correction manuelle (recoupé par 2 agents). - -### UI / Navigation / VM -- **M29 — `ui/folderlist/FolderListScreen.kt:202+220`** : onboarding racine bloqué après rotation — `pendingDefaultPick` en `remember` (non-saveable), `LaunchedEffect` polling annulé à la rotation, import SAF continu en fond mais `setDefaultRoot()` jamais rappelé → écran figé sur `DefaultRootOnboarding`, re-picker = doublon d'import. -- **M30 — `ui/document/DocumentViewerScreen.kt:130-137`** : position pager perdue à la rotation (`jumpPending = remember`), re-scroll vers `initialResourceId` → page N → retour page initiale. Fix : `rememberSaveable` / mémoriser index courant. -- **M31 — `ui/search/SearchScreen.kt:276-284` + `SearchViewModel.kt:55-72`** : `TextField` branché sur la valeur **debouncée** (300 ms) → frappe affichée par à-coups, IME/autocorrect écrasés. Correct : champ sur requête brute, debounce pour Room seule. -- **M32 — `ui/folderdetail/FolderDetailScreen.kt:196-202`** : Partager sans gate `isShareable` (contraire FolderList `canShare`, `:154-159`) → partage d'un dossier local-only/reçu = op `share` vouée au dead-letter `NOT_FOUND`. -- **M33 — `ui/folderlist/FolderListViewModel.kt:165-173`** : `canShare` stale au login/logout (combine `_defaultRootId`/`_browseFolderId` sans token/auth) → « Partager » reste désactivé jusqu'à navigation après connexion depuis Réglages. -- **M34 — `ui/folderlist/FolderListScreen.kt:333-375 vs 326-330`** : suppression multi-dossiers filtre les items **visibles** alors que `selection.ids` survit à `openBrowseFolder` (jamais clear) → sélection hors-vue abandonnée silencieusement avec snackbar succès. Même classe `ui/search/SearchScreen.kt:290-305` (chips actifs en mode sélection, delete par snapshot). -- **M35 — `ui/document/DocumentViewerScreen.kt:131-144`** : pas de clamp après suppression — supprimer le dernier doc (page 2/2) laisse `pagerState` hors bornes → viewer vide au lieu de retomber sur 1er ou `onBack`. -- **M36 — `ui/settings/SettingsScreen.kt:120-128`** : préférence `SYSTEM` inatteignable (Switch DARK/LIGHT depuis `darkNow`, store + thème supportent SYSTEM) → impossible de revenir à « suivre le système ». -- **M37 — `ui/settings/SettingsViewModel.kt:30-36`** : `load()` écrase une saisie serveur en cours (`_serverUrl` init défaut puis réassigné après `load()` en `init`). - -### Scan / PDF / Review / Thumbnails -- **M38 — `data/repository/ScanRepository.kt:63-78`** : `addPage` avec `sortOrder = pageCount` → doublons après suppression (`ORDER BY sort_order` instable, `swapOrder` ambigu). Cause : compteur au lieu de `MAX+1`. -- **M39 — `ui/scan/ScanViewModel.kt:180/199`** : dimensions stockées (pré-scale) ≠ réelles (downscale 2400px dans `process()`) → fiche `W×H` fausse pour grands quads. -- **M40 — `ui/scan/ScanViewModel.kt:177-203`** : écriture JPEG hors transaction Room (orphelins si insert échoue) ; `deletePage` supprime le fichier **avant** la ligne DB (crash = ligne vers fichier absent → rejoint C8). -- **M41 — `data/repository/FileRepository.kt:206`** : `saveLocalFile` ne remonte jamais `cloud` → `local-cloud` (`existing?.syncStatus ?: …`) → fichier cloud-only réimporté en SAF reste badgé « cloud », ignoré vignette/OCR (`sync_status='local-cloud'` requis, `FileDao.kt:137`). -- **M42 — `ui/pdfbuilder/PdfBuilderViewModel.kt:227-237`** : PDF assemblé importé `processed=false` (défaut omis, contraire export scan `true`) → atterrit en review alors que l'utilisateur vient de le construire. -- **M43 — `ui/review/SwipeReviewViewModel.kt:68-74,94-100`** : retrait optimiste sans réinsertion sur échec (`keep`/`markAllProcessed`, contraire `delete` qui réinsère) → carte perdue jusqu'au prochain `load()` (init seule). -- **M44 — `ui/pdfbuilder/PdfBuilderScreen.kt:248`** : `remember(files)` réinitialise la sélection à chaque update Room → cases cochées effacées pendant un refresh serveur. -- **M45 — `ui/pdfbuilder/PdfBuilderEngine.kt:104-107`** : pages PDF sources plafonnées à 1200pt malgré commentaire « format conservé » (`min(1, 1200/max, 3000/max)`, le 1200 gagne toujours) → pixellisation A3/300dpi. -- **M46 — `features/scan/CornerGeometry.kt:19-26`** : `orderPoints` sans validation dégénérescence (doublons/quad aplati) → `outputSize = 0` → bitmap 1×1 validé (page blanche) au lieu d'erreur. -- **M47 — `ui/scan/CameraStage.kt:162-181`** : overlay calibré sur flux `ImageAnalysis` (hypothèse `FILL_CENTER`) alors que `PreviewView` affiche le flux `Preview` (ratio/crop différents) → quad décalé systématiquement quand les ratios diffèrent. +- **M5 — `features/saf/FileDeleter.kt:88-104` + `features/saf/FolderDeleter.kt:91-103`** : `deleteInCloud` sans tombstone locale (`exists` reste 1) → ressource toujours affichée, walk la revoit, `refreshFromServer` ne supprime jamais de lignes → fantôme local vs serveur supprimé. +- **M9 — `features/saf/FolderMerger.kt:59,65-101`** : merge toujours multi-transactions (create, moves, deletes séparés) ; seule idempotence `findExistingMerged:154-161` ajoutée, pas d'atomicité → crash à mi-fusion = état partiel poussé. +- **M13 — entités `exists: Int? = null` + filtres `= 1`** (`FolderEntity.kt:36`, `FileEntity.kt:46`, `FolderDao.kt:43,50`, `FileDao.kt:27,44`) : toute ligne sans `exists` explicite disparaît UI/recherche/review — perte fonctionnelle silencieuse. +- **M27 — `data/repository/ShareRepository.kt:47` + `data/remote/dto/Dtos.kt:150-151`** : snapshot permissions sans delta (`after` jamais passé), `sharedById`/`expiresAt` en `Any?` jamais lus, `cachedAt` jamais persisté, aucun downgrade 24h ni `canAccess` → grant révoqué/expiré reste visible et ouvrable (`404`) jusqu'au prochain login. --- -## 🟡 Mineurs (UX, perf, dette) +## 🟡 Mineurs restants (8) — ✅ tous corrigés le 2026-09-24 (162/162 tests verts) ### Sync / Worker / SAF -- **m1 — `features/sync/SyncViewModel.kt:103-121`** : `_walkInProgress` sans `finally` (reste `true` si scope annulé) → badge « syncing » collé ; la fenêtre inclut l'appel réseau partage. -- **m2 — `features/sync/SyncViewModel.kt:106-112`** : `OutboxSyncWorker.enqueue` + `OcrAutoWorker.enqueue` à chaque tick même sans changement → réveils WorkManager / 30s pour rien. -- **m3 — `features/sync/OutboxSyncWorker.kt:97-100`** : 401 → `success()` sans re-signal, ops pendantes figées jusqu'au prochain tick/login (bénin, `AuthViewModel` ré-enqueue au re-login). -- **m4 — `features/sync/SafScanner.kt:132-139`** : `cursor.getString(iDoc)` sans garde `iDoc == -1`, `name` plateforme-nullable déréférencé → provider dégénéré = crash de tout `scanTree` à chaque tick. -- **m5 — `features/sync/DeviceSync.kt:75-137`** : « transaction courte » en réalité géante (N upserts + `getAll()` dossiers **et** fichiers par racine, O(racines×DB) sous verrou écriture) → lecteurs Room bloqués, jank/ANR sur grosses arborescences. -- **m6 — `features/saf/FolderDeleter.kt:74-88`** : `deleteLocally` multi-writes hors transaction (contraire `treeMarkMissing`) → kill à mi-chemin = `exists` partiel. +- **m1 — `features/sync/SyncViewModel.kt:108-133`** : `_walkInProgress` sans `finally` dans la boucle (reste `true` si scope annulé ; seul `importRoot:173` a un `finally`) → badge « syncing » collé ; la fenêtre inclut l'appel réseau partage. +- **m2 — `features/sync/SyncViewModel.kt:110-116`** : `OutboxSyncWorker.enqueue` + `OcrAutoWorker.enqueue` à chaque tick même sans changement → réveils WorkManager / 30s pour rien. +- **m5 — `features/sync/DeviceSync.kt:76-162`** : « transaction courte » en réalité géante (N upserts + `getAll()` dossiers **et** fichiers par racine sous verrou écriture) → lecteurs Room bloqués, jank/ANR sur grosses arborescences. ### Room / Domain / DI -- **m7 — `data/local/dao/FileDao.kt:30-37`** : `searchWithFilters` `LIKE` brut sans `ESCAPE`, casse ASCII-only → `%`/`_` = jokers (match-all), « ete » ne trouve pas « ÉTÉ ». -- **m8 — `data/local/FileOrdering.kt:5-11`** : tri mémoire (`referenceDate` seule) divergent du SQL (`name ASC` tiebreak, `FileDao.kt:21,43`) ; `lastModified = 0` SAF trié comme plus vieux → ordre incohérent + fichiers `0` enfouis. -- **m9 — `data/local/dao/PendingOperationDao.kt:30-32`** : commentaire `MAX_PENDING_ATTEMPTS` contredit le code (`markFailed()` = dead-letter immédiate, `attempts` diagnostique) — trompeur pour futurs appelants (cohérent avec worker, seul le commentaire est faux). -- **m10 — `data/local/dao/FileDao.kt:89`** : `updateUri` ne touche pas `updated_at` → ordre de convergence faussé après move. -- **m11 — `domain/LocalModeStore.kt:24`** : `get()` teste `!= null` au lieu de `== "1"` → toute valeur parasite (`"0"`, `""`) = mode local actif à tort. -- **m12 — `domain/ServerConfigStore.kt:40-44` + `domain/ThemePreferenceStore.kt:28-32`** : `load()` once-only (`AtomicBoolean`, sans réarmement) → après wipe/logout, URL/thème périmés en mémoire. -- **m13 — `domain/ThemePreferenceStore.kt:34-39`** : `set()` publie le `StateFlow` avant succès DB → divergence UI/DB si upsert échoue. -- **m14 — `domain/PrefKeys.kt:8`** : clé `SYNC_MODE` morte (0 usage, grep vérifié) → dérive spec/impl. -- **m15 — `di/DatabaseModule.kt:25-28`** : aucune stratégie de downgrade → APK plus ancien sur DB v11 = crash `IllegalStateException` au lieu de dégradation contrôlée. -- **m16 — index composites manquants** (`PendingOperationEntity.kt:20-27`, `FileEntity.kt:18-26`, `PendingOperationDao.kt:13`, `FileDao.kt:133-145`) : `selectPending` et `getOcrAutoCandidates` = full-table scan → jank/batterie à 10k lignes. -- **m17 — `data/local/entity/FileEntity.kt:56-57` vs `Migrations.kt:92`** : `processed` sans `defaultValue` Room alors que la migration met `DEFAULT 0` (contraire `createdInApp`, `FolderEntity.kt:43`) → fresh-install ≠ migré. -- **m18 — `data/local/dao/ScanDao.kt:48-57`** : `swapOrder` sans contrôle d'appartenance ni transaction → swap inter-sessions corrompt `sort_order`, concurrence = doublons. -- **m19 — `data/local/AppDatabase.kt:27-34`** : `exportSchema = false`, migrations non snapshotées → dérives indétectables en CI. -- **m20 — `data/repository/OcrRepository.kt:66-73`** : `poll()` infini (`while(true)` + 3s, sans timeout) alors qu'un job peut rester `processing` 15 min (stale claim serveur) → coroutine tenue indéfiniment. -- **m21 — `data/repository/OutboxRepository.kt`** : ops contrat non émissibles (`update_metadata`, `update_share`, `create_link`, `revoke_link` — §6.1 = 9 ops, 5 helpers) → rename partagé, update share, liens publics inopérants. -- **m22 — `data/remote/ApiService.kt`** : endpoints contrat absents (`PATCH /users/me/password`, `GET/DELETE /files/:id`, `GET /files/search`, `GET /shares/links/:token`) → changement mot de passe impossible avec tokens 7j non révoqués. -- **m23 — `data/repository/AuthRepository.kt:21-35`** : `registerDevice` best-effort avale tout (y compris 400/429) → `INVALID_DEVICE_ID`/`RATE_LIMITED` invisibles, 401 trompeur plus tard. -- **m24 — `ui/auth/AuthViewModel.kt:52-55`** : `registerDevice()` émis même en mode local (pas de garde contrairement à `syncSnapshot`). -- **m25 — `di/NetworkModule.kt:37-43`** : logging `BASIC` en DEBUG loggue les query PII (`GET /users/resolve?username=…`) dans logcat. -- **m26 — `data/remote/AuthInterceptor.kt:20-26`** : `Bearer` joint aux routes publiques (`POST /devices`, `POST /auth/login`) — serveur l'ignore mais hygiène + amplification de la fuite M26. -- **m27 — `auth/SessionManager.kt:33-38`** : `expiresAt` du login jeté (paseto TTL 7j) → expiration découverte par 401 brutal, impossible de pré-relancer. -- **m28 — `auth/SecureTokenStore.kt:27-36`** : init Keystore/`EncryptedSharedPreferences` au construct Hilt + I/O synchrone possiblement Main (`MasterKeys` déprécié) → ANR au restore, crash Direct Boot avant déverrouillage. +- **m7 — `data/local/dao/FileDao.kt:45`** : `searchWithFilters` `LIKE` brut sans `ESCAPE`, casse ASCII-only → `%`/`_` = jokers (match-all), « ete » ne trouve pas « ÉTÉ ». +- **m15 — `di/DatabaseModule.kt:25-28`** : aucune stratégie de downgrade → APK plus ancien sur DB v14 = crash `IllegalStateException` au lieu de dégradation contrôlée. +- **m19 — `data/local/AppDatabase.kt:36-37`** : `version=14, exportSchema=false`, migrations non snapshotées → dérives indétectables en CI. -### UI -- **m29 — `ui/navigation/NavGraph.kt:50`** : `pdfBuilder(listOf())` → `"pdfbuilder/"` ne matche pas `"pdfbuilder/{ids}"` (protégé aujourd'hui par `enabled = ids.isNotEmpty()` — contrat implicite fragile). -- **m30 — `ui/navigation/NavGraph.kt:53-59,165`** : `folder/…` sans `launchSingleTop` → double-tap = doublon de pile. -- **m31 — `ui/navigation/KazierApp.kt:54-63`** : `rememberNavController()` par branche SignedIn↔Local → `signOutToLocal()` perd la position d'exploration (hoister le controller). -- **m32 — `ui/folderdetail/FolderDetailScreen.kt:395-429`** : dossiers non sélectionnables dans le détail (vs FolderList) — incohérence partage/multi-suppression inter-écrans. -- **m33 — `ui/pdfbuilder/PdfBuilderScreen.kt:104-114`** : `LaunchedEffect(buildPhase)` rejoue side-effects à la recomposition racine (rotation → `Failed` re-snackbar, `Saved` re-`onOpenDocument` = double navigation possible). -- **m34 — dialogs `remember` perdus à la rotation** (`SyncStatusBadge.kt:129`, `showDeleteWarning/Confirm`, `showMoveDialog`, `showShareSheet`, `showNameDialog`) — sûr mais UX ; `showOcrDialog` en `rememberSaveable` = bon exemple. -- **m35 — `ui/components/WatchedFoldersBadge.kt:36-40` + `WatchedFoldersViewModel.kt:25-27`** : double instance VM + `SharingStarted.Eagerly` collecte Room en continu même sur autres onglets. -- **m36 — `ui/settings/SettingsViewModel.kt:43-48`** : `onServerUrlChange` écrit en prefs à chaque frappe (churn IO) ; commentaire `testConnection` obsolète. -- **m37 — `MainActivity.kt:27-33`** : `themePreferenceStore.load()` fire-and-forget → flash de thème aux premières frames. -- **m38 — `ui/navigation/NavGraph.kt:213-219`** : bandeau import global chevauchant la FloatingNavBar, doublon des indicateurs par-écran. -- **m39 — `ui/pdfbuilder/PdfBuilderViewModel.kt:236`** : `syncStatus="local"` en littéral au lieu de `FileStatus.LOCAL` — fonctionne mais casse silencieusement à toute renommée. +### Sync contrat / OCR +- **m20 — `data/repository/OcrRepository.kt:66-73`** : `poll()` infini (`while(true)` + 3s, sans timeout) alors qu'un job peut rester `processing` longtemps (stale claim serveur) → coroutine tenue indéfiniment. +- **m21 — `data/repository/OutboxRepository.kt:72-147`** : ops contrat non émissibles (`update_metadata`, `update_share`, `create_link`, `revoke_link` — §6.1 = 9 ops, helpers partiels) → rename partagé, update share, liens publics inopérants. -### Scan / PDF / Thumbnails -- **m40 — `ui/scan/CameraStage.kt:86-91`** : `ImageCapture` forcé 1920×1080 paysage → sur portrait, bitmap pleine-rés + copie tournée (×2 mémoire ~16 Mo) → OOM petits devices. -- **m41 — `ui/scan/CameraStage.kt:165-181`** : `toBitmap()` pleine-rés à chaque frame d'analyse (~30fps) puis downscale interne → churn GC + batterie. -- **m42 — `ui/scan/CameraStage.kt:99-101`** : `addOnLayoutChangeListener` jamais retiré → fuite mineure du listener. -- **m43 — `ui/scan/CameraStage.kt:200-211`** : `when` rotation sans `else` → angle inattendu = copie silencieuse au lieu d'erreur. -- **m44 — `ui/scan/ScanGeometry.kt:42-69`** : division par zéro si `sourceRect` dégénérée (`Infinity/NaN` dans le quad ; inatteignable via `initialViewport` mais API publique exposée). -- **m45 — `ui/scan/CropStage.kt:188-193`** : arrondi `roundToInt` viewport indépendant de l'offset → dépassement 1px en bordure (frange noire sur images impaires). -- **m46 — `ui/scan/ScanViewModel.kt:111-122`** : `combine(pages, pageCount)` avec count ignoré → réassignations `_pages` redondantes. -- **m47 — `ui/scan/ScanViewModel.kt:409-418`** : `abandon()` laisse sessions vides `ABANDONED` jamais purgées + `sessionDir()` fait `mkdirs()` en getter (recrée ce qu'on supprime). -- **m48 — `data/repository/ScanRepository.kt:27-40`** : race `getOrCreateActiveSession` (double `active` possible, aucune unicité partielle ; fenêtre étroite). -- **m49 — `domain/FileCategory.kt:19-27`** : CSV classé `TEXT` (par MIME) ou `OFFICE` (par extension) selon le chemin → icône/filtres/OCR divergents pour le même fichier. -- **m50 — `features/thumbnails/ThumbnailStore.kt:51`** : map de `Mutex` jamais purgée → fuite lente par `resourceId`. -- **m51 — `features/thumbnails/ThumbnailStore.kt:104-112`** : `.tmp` orphelin si `renameTo` échoue → résidus `*.webp.tmp`. -- **m52 — `features/thumbnails/ThumbnailStore.kt:83-87`** : `isUpToDate` sur `mtime` seule (granularité seconde SAF) → vignette périmée après édition rapide (pas de taille/hash). -- **m53 — `ui/pdfbuilder/PdfBuilderEngine.kt:121-124`** : `renderer?.close()` non protégé (si `close()` lève, `pfd.close()` sautée → fd leak ; `ThumbnailStore.renderPdfPage` fait `runCatching`). -- **m54 — `features/scan/CornerGeometry.kt:40-45`** : commentaire « moyenne » mais code `max` → warp légèrement étiré vs réel. -- **m55 — `features/scan/ScanImageProcessor.kt:126-181`** : mats de contours non libérés sur exception (`c.release()` chemin nominal seul) → fuite native OpenCV. -- **m56 — `ui/review/SwipeReviewViewModel.kt:52-64`** : échec de reload écrase le deck (`update{cards=files}` même sur `emptyList` d'erreur) → deck vidé à tort. +--- + +## 🛠️ Plans de correction (reliquat) — ✅ implémentés le 2026-09-24 + +Ordre suivi : M13 → M5 → M27+m21 → M9 → mineurs par lot (m1+m2, m5, m7, m20, m15+m19). +Écarts d'implémentation vs plan : M13 sans rewrite (colonne restée nullable, défaut Kotlin 1 + backfill — pas de bump de contrainte) ; m7 `COLLATE NOCASE` sans colonne normalisée (repli Unicode « ete » → « ÉTÉ » toujours ouvert, voir suivi) ; M27 `cachedAt` persisté = heure locale du pull (pas l'horloge serveur, skew). + +### M5 — `deleteInCloud` sans tombstone locale +Fichiers : `features/saf/FileDeleter.kt:88-104`, `features/saf/FolderDeleter.kt:91-103` (+ descendants via `collectDescendants`). +Constat : `deleteInCloud` enqueue `delete_resource` mais laisse `exists = 1` ; la ressource reste affichée et le walk la revoit. +Plan : +1. Dans `FileDeleter.deleteInCloud`, après `enqueueDeleteResource`, appeler `fileRepository.markMissing(resourceId, now)` dans la même transaction Room (ou `appDatabase.withTransaction` comme `deleteFull`). +2. Dans `FolderDeleter.deleteInCloud`, idem pour le dossier ET sa descendance Room (`treeMarkMissing`-léger : `markMissing` sur fichiers + sous-dossiers, sans `delete_resource` supplémentaire sauf si `hasSyncedCreateOperation`). +3. Vérifier que le walk ne ressuscite pas : les lignes `exists = 0` + `delete_resource` pending doivent être ignorées par la réconciliation (garde `hasPendingDeleteOperation`, cf. `OutboxRepository.kt:204`). +4. UI : vérifier que les listes filtrent `exists = 1` (déjà le cas) → la ligne disparaît aussitôt. +Tests : étendre `ProcessedGateTest` ou nouveau `DeleteInCloudTest` — `deleteInCloud` puis assert `exists == 0` + op `delete_resource` présente ; walk simulé ne ressuscite pas. + +### M9 — `FolderMerger` multi-transactions non-atomique +Fichier : `features/saf/FolderMerger.kt:53-106`. +Constat : `createMergedFolder` (transaction 1), moves (N transactions via `FileMover`/`reparentSubFolders`), deletes (N transactions). Un crash à mi-fusion laisse un état partiel ; la relance est idempotente (dossier réutilisé) mais ne reprend pas les moves manquants proprement. +Plan : +1. Envelopper `mergeSelectedFolders` dans `appDatabase.withTransaction` pour la partie Room (create + reparent + `treeMarkMissing`) — nécessite d'injecter `AppDatabase` dans `FolderMerger` et de rendre `FileMover.moveFiles` / `reparentSubFolders` appelables dans une transaction existante (ou journaliser les `move_resource`/`delete_resource` dans la transaction et n'exécuter le SAF physique qu'avant/après selon le sens crash-safe : journal-first comme C4). +2. Ordre crash-safe : (a) transaction Room = create + moves logiques + deletes logiques (`exists = 0` + outbox), (b) exécution SAF physique (moves + deletes), (c) sweep au prochain tick pour les physiques manqués (réutiliser `sweepPendingPhysicalDeletes`). +3. Garder l'idempotence `findExistingMerged` pour les relances. +4. À défaut d'une transaction unique (SAF non transactionnel), a minima : rendre chaque étape reprise-safe (skip les sources déjà vides, skip les moves déjà journalisés via `hasPendingMoveOperation`). +Tests : nouveau `FolderMergerTest` — fusion 2 dossiers avec fichiers + sous-dossier, assert `movedFiles/deletedFolders`, relance idempotente (pas de doublon), crash simulé entre étape 2 et 3 → reprise sans perte. + +### M13 — `exists: Int? = null` invisible +Fichiers : `data/local/entity/FolderEntity.kt:36`, `data/local/entity/FileEntity.kt:46`, DAO (`FolderDao`, `FileDao` filtres `= 1`), `Migrations.kt` (créations tables sans `DEFAULT 1` / `NOT NULL`). +Constat : toute ligne insérée sans `exists` explicite (défaut Kotlin `null`) est cachée par les requêtes `WHERE exists = 1`. +Plan : +1. Durcir les entités : `exists: Int = 1` (non-null, défaut 1) dans `FolderEntity` et `FileEntity`. +2. Migration v14→v15 : `UPDATE folders SET exists = 1 WHERE exists IS NULL`, idem `files`, puis recréation ou `NOT NULL DEFAULT 1` (Room : via `autoMigrations` ou SQL `ALTER` + table rewrite selon la version SQLite ; le plus simple : `UPDATE` + contrainte applicative + défaut entité, sans rewrite si Room accepte le changement nullable→non-null via migration manuelle avec recréation de table). +3. Auditer tous les `saveFolder`/`saveLocalFile`/`upsertShared*` pour passer `exists = 1` explicitement. +4. Option : ajouter un test `ExistsDefaultTest` — insert sans `exists`, assert visible dans `observeByFolder`/`searchWithFilters`. +Note : migration à tester via `Migration13To14Test`-style (nouveau `Migration14To15Test`) + `:app:testDebugUnitTest`. + +### M27 — snapshot permissions sans delta ni `canAccess` +Fichiers : `data/repository/ShareRepository.kt:44-47`, `data/remote/dto/Dtos.kt:144-156` (`sharedById`/`expiresAt: Any?`), `data/remote/ApiService.kt:74-78`, `ApiClient.kt:106-108`. +Constat : `syncPermissions()` sans `after`, champs `sharedById`/`expiresAt` jamais lus, `cachedAt` jamais persisté, aucun downgrade TTL 24h ni `canAccess` → grants révoqués/expirés visibles jusqu'au prochain login. +Plan : +1. DTO : typer `sharedById: String?`, `expiresAt: Long?` (le serveur renvoie ms epoch ou null — vérifier `docs/api-v1.md §6.2` et adapter avec un adapter Moshi tolérant `Any?`→Long). +2. Persistance : stocker `cachedAt`/`expiresAt`/`sharedById`/`effectiveAccess` — soit colonnes sur `files`/`folders`, soit nouvelle table `resource_permissions` (préférable : ne pas polluer les entités). A minima `user_preferences` : `permissions_cached_at`. +3. Delta : `syncSnapshot(after: Long? = cachedAt)` → `apiClient.syncPermissions(after)` ; pull complet (`after = null`) au login/restauration + quand `now - cachedAt > 24h` (TTL). +4. Expiration locale : au tick, marquer `exists = 0` les lignes dont `expiresAt < now` ; downgrade lecture seule après TTL sans reseed (gate `canAccess` : à exposer via `ShareRepository.canAccess(resourceId, required)` utilisé par les VM avant open/share/rename). +5. `canAccess` : ranking viewer < commenter < editor < owner, `ownerId == currentUser` → owner. +Tests : étendre `ShareRepositoryTest` — delta `after`, révocation (absent du snapshot → `markMissing`), expiration (`expiresAt` passé → masqué), `canAccess` ranking. + +### m1+m2 — badge sync et réveils WorkManager +Fichier : `features/sync/SyncViewModel.kt:100-137`. +Plan : +1. m1 : envelopper le corps de boucle dans `try { … } finally { _walkInProgress.value = false }` (comme `importRoot:173-176`), et sortir `syncSnapshot` de la fenêtre `_walkInProgress` (flag séparé ou `syncing` = walk || drain déjà calculé via WorkManager). +2. m2 : n'enqueuer `OutboxSyncWorker`/`OcrAutoWorker` que si le tick a produit quelque chose (`results.any { folders+files+missing > 0 }` ou `pendingOperationDao.countPending() > 0` / fichier promu). Éviter les réveils /30s à vide. +Tests : Robolectric `SyncViewModelTest` — annulation du scope → flag retombe ; tick sans changement → `WorkManager` non sollicité (mock/static ou extraction d'un `SyncScheduler` testable). + +### m5 — walk : transaction géante + `getAll()` par racine +Fichier : `features/sync/DeviceSync.kt:67-163`. +Plan : +1. Découper la phase 2 : upserts dossiers/fichiers par batch (ex. 200) en transactions courtes successives au lieu d'une transaction unique ; la réconciliation `missing` en passe séparée. +2. Remplacer `folderRepository.getAll()` + `fileRepository.getAll()` (full-table scan par racine) par des requêtes scopées à la racine (`getByRootUri`/`getDescendants`) — à ajouter aux DAO avec index sur `uri` (déjà unique) ; filtrer en SQL plutôt qu'en mémoire (`isChildOf` en `LIKE rootUri || '/%'`). +3. Conserver le `Mutex` single-flight ; vérifier `ensureActive()` dans les boucles longues pour annulation propre. +Tests : `SafScannerTest`-style perf — 5k fichiers simulés, assert temps/absence d'ANR ; test de convergence identique avant/après. + +### m7 — recherche `LIKE` sans `ESCAPE` +Fichier : `data/local/dao/FileDao.kt:42-49`. +Plan : échapper `%`, `_`, `\` dans `:query` côté repository (`searchFiles`) + `LIKE … ESCAPE '\'` dans la requête ; ajouter `COLLATE NOCASE` (ou normalisation) pour « ete » → « ÉTÉ ». Tester : `%`, `_`, `\`, accents, casse. +Tests : `SearchFieldTest` ou nouveau `SearchEscapeTest` — `%` littéral ne matche pas tout, `_` littéral, insensible à la casse. + +### m20 — `OcrRepository.poll()` infini +Fichier : `data/repository/OcrRepository.kt:66-73`. +Plan : ajouter timeout (ex. 10 min) + nombre max de polls + backoff ; lever `OcrTimeoutException` ou retourner le dernier état ; coopérer avec l'annulation (`ensureActive`). Mettre à jour les appelants (viewer auto) pour afficher « OCR indisponible, réessayer ». +Tests : `OcrRepositoryTest` — job restant `processing` → timeout au bout de N polls (fake `ApiClient` + virtual time/delays courts). + +### m15+m19 — robustesse DB (downgrade + `exportSchema`) +Fichiers : `di/DatabaseModule.kt:25-28`, `data/local/AppDatabase.kt:31-38`. +Plan : +1. m19 : `exportSchema = true` + `schemas/` commité ; ajouter un test `Migration13To14Test`-style qui échoue en cas de dérive (CI). +2. m15 : stratégie downgrade explicite et documentée — soit `fallbackToDestructiveMigrationOnDowngrade()` (avec avertissement perte de données locales, acceptable car miroir SAF + outbox non poussée à préserver → plutôt refuser le démarrage avec message), soit crash contrôlé avec écran « mettez à jour l'app ». Choisir et documenter ; ne jamais laisser `IllegalStateException` brut. +Tests : build avec `exportSchema=true` + `room.schemaLocation` ; test downgrade (ouverture v15 avec APK v14 → comportement attendu). + +### m21 — ops contrat non émissibles +Fichiers : `data/repository/OutboxRepository.kt:72-147`, `data/local/entity/PendingOperationEntity.kt:76-86` (constantes déjà présentes : `UPDATE_METADATA`, `UPDATE_SHARE`, `CREATE_LINK`, `REVOKE_LINK`). +Plan : ajouter `enqueueUpdateMetadata(resourceId, resourceType, name?)`, `enqueueUpdateShare(...)`, `enqueueCreateLink(resourceId, resourceType, token, access, expiresAt?)`, `enqueueRevokeLink(...)` avec payloads §6.1 (`granteeUserId/access/inherit/expiresAt`, `token/access/expiresAt`) ; brancher les appelants (rename partagé, update share, liens publics) ; `GenerateId` pour `token` 32-hex côté client. +Tests : `OutboxSyncWorkerTest`-style — sérialisation payload, `normalizePayloadNumbers` (`expiresAt` Long exact, non `1.7E12`), round-trip `POST /sync/ops` mocké. --- @@ -195,7 +151,7 @@ Repro : device sans lib OpenCV → valider un crop → crash au retour caméra. - Ordre interceptors `serverUrl → auth → logging`, `BASIC` ne log ni headers ni bodies — OK. - Contrat HTTP conforme sur endpoints déclarés (query `folderId/page/pageSize`, `deviceId` camel vs `device_id` login, multipart `file`/`resourceId`/`folderId`, enveloppes `{data,meta}`/`{error:{code,message}}`, codes) — OK. - `device_id` claim jamais utilisé comme preuve, seul le `Bearer` parle — conforme middleware. -- Worker no-op en mode local (`OutboxSyncWorker.kt:71`), batch 20 ≤ 100 serveur, statuts OCR, `resolveUser` trim compatible, password jamais trimé — OK. +- Worker no-op en mode local (`OutboxSyncWorker.kt:111`), batch 20 ≤ 100 serveur, statuts OCR, `resolveUser` trim compatible, password jamais trimé — OK. - Deep-links : aucun défini (absence, pas de bug) ; args nav `folderResourceId`/`documentResourceId`/`ids` cohérents, 32-hex sans `/`. - Hilt : `MainActivity @AndroidEntryPoint`, tous `hiltViewModel()` ↔ `@HiltViewModel`, scopes corrects — aucune injection manquante. - Pas de recomposition infinie trouvée ; `collectAsStateWithLifecycle` partout ; placeholder cloud-only correct (`DocumentContentViewer.kt:39-47`) ; recherche 100 % locale conforme V1 ; back stack onglets correct (`saveState`/`restoreState`) ; `SelectionState` volatile documenté volontaire. diff --git a/mise.toml b/mise.toml index 4c51742..3f0c9e7 100644 --- a/mise.toml +++ b/mise.toml @@ -21,9 +21,32 @@ set -euo pipefail ./gradlew :app:assembleDebug -q APK="app/build/outputs/apk/debug/app-debug.apk" if [ "${usage_target?}" = "emulator" ]; then - adb -e install -r "$APK" + ADB_FLAGS=(-e) else - adb -d install -r "$APK" + ADB_FLAGS=(-d) +fi +# adb natif s'il fonctionne (PATH + binaire exécutable sur cet OS)... +if command -v adb >/dev/null 2>&1 && adb version >/dev/null 2>&1; then + adb "${ADB_FLAGS[@]}" install -r "$APK" +# ...sinon repli NixOS : l'adb du SDK est un binaire FHS dynamiquement +# lié, on l'exécute via steam-run (cf. local.properties pour sdk.dir). +elif command -v steam-run >/dev/null 2>&1; then + SDK_DIR="${ANDROID_SDK_ROOT:-${ANDROID_HOME:-}}" + if [ -z "$SDK_DIR" ] && [ -f local.properties ]; then + SDK_DIR="$(sed -n 's/^sdk\.dir=//p' local.properties | head -n 1)" + fi + if [ -z "$SDK_DIR" ] && [ -d "$HOME/Android/Sdk" ]; then + SDK_DIR="$HOME/Android/Sdk" + fi + if [ -z "$SDK_DIR" ] || [ ! -x "$SDK_DIR/platform-tools/adb" ]; then + echo "adb introuvable : définissez ANDROID_HOME ou sdk.dir dans local.properties." >&2 + exit 1 + fi + export LD_LIBRARY_PATH="${LD_LIBRARY_PATH:-}:$HOME/.nix-profile/lib:/run/opengl-driver/lib" + steam-run "$SDK_DIR/platform-tools/adb" "${ADB_FLAGS[@]}" install -r "$APK" +else + echo "adb ne fonctionne pas sur cet OS et steam-run est absent (NixOS)." >&2 + exit 1 fi ''' diff --git a/mobile-kotlin/app/build.gradle.kts b/mobile-kotlin/app/build.gradle.kts index 922ddce..fef77b7 100644 --- a/mobile-kotlin/app/build.gradle.kts +++ b/mobile-kotlin/app/build.gradle.kts @@ -84,6 +84,11 @@ android { } } +// m19 : export du schéma Room (`app/schemas/`) pour détecter les dérives en CI. +ksp { + arg("room.schemaLocation", "$projectDir/schemas") +} + dependencies { implementation(libs.androidx.core.ktx) implementation(libs.androidx.lifecycle.runtime.ktx) diff --git a/mobile-kotlin/app/schemas/com.kazier.mobile.data.local.AppDatabase/16.json b/mobile-kotlin/app/schemas/com.kazier.mobile.data.local.AppDatabase/16.json new file mode 100644 index 0000000..f2562dc --- /dev/null +++ b/mobile-kotlin/app/schemas/com.kazier.mobile.data.local.AppDatabase/16.json @@ -0,0 +1,730 @@ +{ + "formatVersion": 1, + "database": { + "version": 16, + "identityHash": "ec10fdb23d5da3a76a73222e9c404561", + "entities": [ + { + "tableName": "folders", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `exists` INTEGER, `parent_resource_id` TEXT, `owner_id` TEXT, `sync_status` TEXT NOT NULL, `created_in_app` INTEGER NOT NULL DEFAULT 0, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "uri", + "columnName": "uri", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "name", + "columnName": "name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "exists", + "columnName": "exists", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "parentResourceId", + "columnName": "parent_resource_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "ownerId", + "columnName": "owner_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "syncStatus", + "columnName": "sync_status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdInApp", + "columnName": "created_in_app", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "addedAt", + "columnName": "added_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_folders_resource_id", + "unique": true, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + }, + { + "name": "index_folders_uri", + "unique": true, + "columnNames": [ + "uri" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_uri` ON `${TABLE_NAME}` (`uri`)" + }, + { + "name": "index_folders_parent_resource_id", + "unique": false, + "columnNames": [ + "parent_resource_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_folders_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "user_preferences", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`key` TEXT NOT NULL, `value` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`key`))", + "fields": [ + { + "fieldPath": "key", + "columnName": "key", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "value", + "columnName": "value", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "key" + ] + }, + "indices": [], + "foreignKeys": [] + }, + { + "tableName": "files", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `folder_resource_id` TEXT NOT NULL, `extension` TEXT, `size` INTEGER NOT NULL, `mime_type` TEXT, `exists` INTEGER, `last_modified` INTEGER, `owner_id` TEXT, `category` TEXT, `sync_status` TEXT NOT NULL, `content` TEXT, `processed` INTEGER NOT NULL, `ocr_text` TEXT, `ocr_attempts` INTEGER NOT NULL, `ocr_queued_at` INTEGER, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "uri", + "columnName": "uri", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "name", + "columnName": "name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "folderResourceId", + "columnName": "folder_resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "extension", + "columnName": "extension", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "size", + "columnName": "size", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "mimeType", + "columnName": "mime_type", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "exists", + "columnName": "exists", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "lastModified", + "columnName": "last_modified", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "ownerId", + "columnName": "owner_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "category", + "columnName": "category", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "syncStatus", + "columnName": "sync_status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "processed", + "columnName": "processed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "ocrText", + "columnName": "ocr_text", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "ocrAttempts", + "columnName": "ocr_attempts", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "ocrQueuedAt", + "columnName": "ocr_queued_at", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "addedAt", + "columnName": "added_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_files_resource_id", + "unique": true, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + }, + { + "name": "index_files_uri", + "unique": true, + "columnNames": [ + "uri" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_uri` ON `${TABLE_NAME}` (`uri`)" + }, + { + "name": "index_files_folder_resource_id", + "unique": false, + "columnNames": [ + "folder_resource_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_files_folder_resource_id` ON `${TABLE_NAME}` (`folder_resource_id`)" + }, + { + "name": "index_files_category", + "unique": false, + "columnNames": [ + "category" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_files_category` ON `${TABLE_NAME}` (`category`)" + }, + { + "name": "index_files_exists_processed_sync_status", + "unique": false, + "columnNames": [ + "exists", + "processed", + "sync_status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_files_exists_processed_sync_status` ON `${TABLE_NAME}` (`exists`, `processed`, `sync_status`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "pending_operations", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`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, `parent_resource_id` TEXT, `status` TEXT NOT NULL, `attempts` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deviceId", + "columnName": "device_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "operationId", + "columnName": "operation_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "refType", + "columnName": "ref_type", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "refId", + "columnName": "ref_id", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "resourceType", + "columnName": "resource_type", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "operation", + "columnName": "operation", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "payload", + "columnName": "payload", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "parentResourceId", + "columnName": "parent_resource_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "attempts", + "columnName": "attempts", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "created_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_pending_operations_device_id_operation_id", + "unique": true, + "columnNames": [ + "device_id", + "operation_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_pending_operations_device_id_operation_id` ON `${TABLE_NAME}` (`device_id`, `operation_id`)" + }, + { + "name": "index_pending_operations_status", + "unique": false, + "columnNames": [ + "status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_status` ON `${TABLE_NAME}` (`status`)" + }, + { + "name": "index_pending_operations_resource_id", + "unique": false, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + }, + { + "name": "index_pending_operations_resource_id_operation_status", + "unique": false, + "columnNames": [ + "resource_id", + "operation", + "status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id_operation_status` ON `${TABLE_NAME}` (`resource_id`, `operation`, `status`)" + }, + { + "name": "index_pending_operations_parent_resource_id", + "unique": false, + "columnNames": [ + "parent_resource_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "scan_sessions", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `root_folder_id` TEXT, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "rootFolderId", + "columnName": "root_folder_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "created_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_scan_sessions_resource_id", + "unique": true, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_sessions_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "scan_pages", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `session_id` INTEGER NOT NULL, `temp_uri` TEXT NOT NULL, `corners_json` TEXT NOT NULL, `width` INTEGER NOT NULL, `height` INTEGER NOT NULL, `sort_order` INTEGER NOT NULL, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, FOREIGN KEY(`session_id`) REFERENCES `scan_sessions`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "sessionId", + "columnName": "session_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "tempUri", + "columnName": "temp_uri", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "cornersJson", + "columnName": "corners_json", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "width", + "columnName": "width", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "height", + "columnName": "height", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "sortOrder", + "columnName": "sort_order", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "created_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_scan_pages_resource_id", + "unique": true, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_pages_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + }, + { + "name": "index_scan_pages_session_id", + "unique": false, + "columnNames": [ + "session_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_session_id` ON `${TABLE_NAME}` (`session_id`)" + }, + { + "name": "index_scan_pages_sort_order", + "unique": false, + "columnNames": [ + "sort_order" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_sort_order` ON `${TABLE_NAME}` (`sort_order`)" + } + ], + "foreignKeys": [ + { + "table": "scan_sessions", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "session_id" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "resource_permissions", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`resource_id` TEXT NOT NULL, `resource_type` TEXT NOT NULL, `effective_access` TEXT NOT NULL, `owner_id` TEXT, `shared_by_id` TEXT, `expires_at` INTEGER, `cached_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`resource_id`))", + "fields": [ + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "resourceType", + "columnName": "resource_type", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "effectiveAccess", + "columnName": "effective_access", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "ownerId", + "columnName": "owner_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "sharedById", + "columnName": "shared_by_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "expiresAt", + "columnName": "expires_at", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "cachedAt", + "columnName": "cached_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "resource_id" + ] + }, + "indices": [ + { + "name": "index_resource_permissions_expires_at", + "unique": false, + "columnNames": [ + "expires_at" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_resource_permissions_expires_at` ON `${TABLE_NAME}` (`expires_at`)" + } + ], + "foreignKeys": [] + } + ], + "views": [], + "setupQueries": [ + "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)", + "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'ec10fdb23d5da3a76a73222e9c404561')" + ] + } +} \ No newline at end of file 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 99f4ede..45a0490 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 @@ -5,11 +5,13 @@ import androidx.room.RoomDatabase import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.dao.PendingOperationDao +import com.kazier.mobile.data.local.dao.ResourcePermissionDao import com.kazier.mobile.data.local.dao.ScanDao import com.kazier.mobile.data.local.dao.UserPreferenceDao import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.PendingOperationEntity +import com.kazier.mobile.data.local.entity.ResourcePermissionEntity import com.kazier.mobile.data.local.entity.ScanPageEntity import com.kazier.mobile.data.local.entity.ScanSessionEntity import com.kazier.mobile.data.local.entity.UserPreferenceEntity @@ -27,14 +29,20 @@ import com.kazier.mobile.data.local.entity.UserPreferenceEntity * operation_id) (contrat outbox docs/api-v1.md §6.1). * v13: index composites files(exists, processed, sync_status) et * pending_operations(resource_id, operation, status) (requêtes review/OCR/gates). + * v14: parent_resource_id sur pending_operations (cascade P8). + * v15: backfill exists NULL→1 sur folders/files (M13). + * v16: table resource_permissions (cache snapshot, M27). */ @Database( entities = [ FolderEntity::class, UserPreferenceEntity::class, FileEntity::class, PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class, + ResourcePermissionEntity::class, ], - version = 14, - exportSchema = false, + version = 16, + // m19 : schéma exporté (`app/schemas/`) — toute dérive non migrée casse + // la compilation au lieu de briqueter les utilisateurs au démarrage. + exportSchema = true, ) abstract class AppDatabase : RoomDatabase() { @@ -43,4 +51,5 @@ abstract class AppDatabase : RoomDatabase() { abstract fun fileDao(): FileDao abstract fun pendingOperationDao(): PendingOperationDao abstract fun scanDao(): ScanDao + abstract fun resourcePermissionDao(): ResourcePermissionDao } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/LikeEscape.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/LikeEscape.kt new file mode 100644 index 0000000..4f4af94 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/LikeEscape.kt @@ -0,0 +1,10 @@ +package com.kazier.mobile.data.local + +/** + * Échappe les jokers `LIKE` (`%`, `_`) et l'échappement lui-même (`\`) dans + * un fragment destiné à une requête `... LIKE ... ESCAPE '\'` (m5, m7). + * Sans ça, un `%`/`_` saisi (recherche) ou présent (uris SAF encodées + * `%3A…`) agit comme joker : match-all en recherche, sur-sélection au walk. + */ +internal fun String.escapeLike(): String = + replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") 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 d96b359..188629d 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,12 @@ interface FileDao { @Query("SELECT * FROM files ORDER BY name ASC") suspend fun getAll(): List + /** + * Lignes sous une racine SAF (m5) — voir `FolderDao.getUnderRoot`. + */ + @Query("SELECT * FROM files WHERE uri = :rootUri OR uri LIKE :escapedRoot || '/%' ESCAPE '\\'") + suspend fun getUnderRoot(rootUri: String, escapedRoot: String): 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 @@ -39,10 +45,17 @@ interface FileDao { @Query("SELECT * FROM files WHERE uri = :uri LIMIT 1") suspend fun getByUri(uri: String): FileEntity? + /** + * Recherche par nom (m7) : `:query` arrive déjà échappé (`escapeLike`, + * `%`/`_` littéraux, pas des jokers) avec `ESCAPE '\'`. `COLLATE NOCASE` + * sur l'opérande gauche pour une casse ASCII insensible explicite + * (le repli Unicode « ete » → « ÉTÉ » demanderait une colonne normalisée, + * hors scope — voir FEEDBACK). + */ @Query(""" SELECT * FROM files WHERE "exists" = 1 - AND (:query IS NULL OR name LIKE '%' || :query || '%') + AND (:query IS NULL OR name COLLATE NOCASE LIKE '%' || :query || '%' ESCAPE '\') AND (:category IS NULL OR category = :category) ORDER BY name ASC """) 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 624686b..363dc1e 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 + /** + * Lignes sous une racine SAF (m5) : le walk et sa réconciliation ne + * scannent plus toute la table par racine. `:escapedRoot` est la racine + * avec `%`, `_`, `\` échappés côté appelant (`ESCAPE '\'`). + */ + @Query("SELECT * FROM folders WHERE uri = :rootUri OR uri LIKE :escapedRoot || '/%' ESCAPE '\\'") + suspend fun getUnderRoot(rootUri: String, escapedRoot: String): List + /** * Repasse C4 (dossiers) : voir `FileDao.getMissingWithUri`. Un dossier * n'est re-supprimé physiquement que si toute sa descendance Room est diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/ResourcePermissionDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/ResourcePermissionDao.kt new file mode 100644 index 0000000..e8a97b7 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/ResourcePermissionDao.kt @@ -0,0 +1,30 @@ +package com.kazier.mobile.data.local.dao + +import androidx.room.Dao +import androidx.room.Query +import androidx.room.Upsert +import com.kazier.mobile.data.local.entity.ResourcePermissionEntity + +@Dao +interface ResourcePermissionDao { + + @Upsert + suspend fun upsertAll(perms: List) + + @Query("SELECT * FROM resource_permissions WHERE resource_id = :resourceId LIMIT 1") + suspend fun getByResourceId(resourceId: String): ResourcePermissionEntity? + + /** Grants périmés à masquer localement (`expires_at` passé). */ + @Query("SELECT * FROM resource_permissions WHERE expires_at IS NOT NULL AND expires_at <= :now") + suspend fun getExpired(now: Long): List + + /** + * Convergence du pull complet : oublie les grants absents du snapshot + * (révocation/expiration côté serveur). + */ + @Query("DELETE FROM resource_permissions WHERE resource_id NOT IN (:snapshotIds)") + suspend fun deleteNotIn(snapshotIds: List) + + @Query("DELETE FROM resource_permissions") + suspend fun clear() +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FileEntity.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FileEntity.kt index 0aac352..2bdbb28 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FileEntity.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FileEntity.kt @@ -42,8 +42,9 @@ data class FileEntity( val size: Long, @ColumnInfo(name = "mime_type") val mimeType: String? = null, + // M13 : voir `FolderEntity.exists` — défaut 1, backfill en migration 14→15. @ColumnInfo(name = "exists") - val exists: Int? = null, + val exists: Int? = 1, @ColumnInfo(name = "last_modified") val lastModified: Long? = null, @ColumnInfo(name = "owner_id") diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FolderEntity.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FolderEntity.kt index 9a6aeaa..4fd6b00 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FolderEntity.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FolderEntity.kt @@ -32,8 +32,11 @@ data class FolderEntity( val uri: String? = null, @ColumnInfo(name = "name") val name: String, + // M13 : défaut 1 — une ligne sans `exists` explicite restait invisible + // des requêtes `WHERE exists = 1`. La colonne reste nullable côté schéma + // (pas de rewrite), le backfill NULL→1 est fait en migration 14→15. @ColumnInfo(name = "exists") - val exists: Int? = null, + val exists: Int? = 1, @ColumnInfo(name = "parent_resource_id") val parentResourceId: String? = null, @ColumnInfo(name = "owner_id") diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/ResourcePermissionEntity.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/ResourcePermissionEntity.kt new file mode 100644 index 0000000..4344bbe --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/ResourcePermissionEntity.kt @@ -0,0 +1,59 @@ +package com.kazier.mobile.data.local.entity + +import androidx.room.ColumnInfo +import androidx.room.Entity +import androidx.room.Index +import androidx.room.PrimaryKey + +/** + * Cache local du snapshot `GET /sync/permissions` (M27, docs/api-v1.md §6.2). + * + * Une ligne = la permission effective connue pour une ressource NON possédée + * (les ressources `owner` ne sont pas stockées : l'ownership se résout depuis + * les lignes `files`/`folders`). Fondement de [canAccess][com.kazier.mobile.data.repository.ShareRepository.canAccess] + * sans réseau : rang effectif, expiration du grant et fraîcheur du snapshot + * (TTL 24h → downgrade lecture seule). + */ +@Entity( + tableName = "resource_permissions", + indices = [ + Index(value = ["expires_at"]), + ], +) +data class ResourcePermissionEntity( + @PrimaryKey + @ColumnInfo(name = "resource_id") + val resourceId: String, + @ColumnInfo(name = "resource_type") + val resourceType: String, + @ColumnInfo(name = "effective_access") + val effectiveAccess: String, + @ColumnInfo(name = "owner_id") + val ownerId: String? = null, + @ColumnInfo(name = "shared_by_id") + val sharedById: String? = null, + /** Fin du grant, ms epoch ; null = jamais. */ + @ColumnInfo(name = "expires_at") + val expiresAt: Long? = null, + /** Horodatage du snapshot serveur, ms epoch (TTL 24h). */ + @ColumnInfo(name = "cached_at") + val cachedAt: Long, + @ColumnInfo(name = "updated_at") + val updatedAt: Long, +) + +/** Rangs d'accès effectif — `viewer < commenter < editor < owner`. */ +object AccessRank { + const val VIEWER = "viewer" + const val COMMENTER = "commenter" + const val EDITOR = "editor" + const val OWNER = "owner" + + fun rank(access: String?): Int = when (access) { + OWNER -> 4 + EDITOR -> 3 + COMMENTER -> 2 + VIEWER -> 1 + else -> 0 + } +} 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 b370d83..eecbfee 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 @@ -33,6 +33,9 @@ import androidx.sqlite.db.SupportSQLiteDatabase * v13 : index composites `files(exists, processed, sync_status)` (review + * candidats OCR auto) et `pending_operations(resource_id, operation, status)` * (gates outbox create/move) — requêtes à chaud sans full-table scan. + * v14 : colonne `parent_resource_id` sur `pending_operations` (cascade P8). + * v15 : backfill `exists` NULL→1 sur `folders`/`files` (M13) + défaut Kotlin 1. + * v16 : table `resource_permissions` (cache snapshot, M27) + index `expires_at`. */ object Migrations { @@ -246,7 +249,49 @@ object Migrations { } } + /** + * M13 : backfill `exists` NULL→1 sur `folders` et `files`. Les lignes + * insérées sans `exists` explicite (défaut Kotlin `null` avant ce fix) + * étaient invisibles des requêtes `WHERE exists = 1` — elles + * réapparaissent comme présentes, état le plus sûr (le walk les + * re-marque `exists = 0` si elles ont vraiment disparu). + */ + private val MIGRATION_14_15 = object : Migration(14, 15) { + override fun migrate(db: SupportSQLiteDatabase) { + db.execSQL("UPDATE `folders` SET `exists` = 1 WHERE `exists` IS NULL") + db.execSQL("UPDATE `files` SET `exists` = 1 WHERE `exists` IS NULL") + } + } + + /** + * M27 : cache du snapshot permissions — table `resource_permissions` + * (rang effectif + expiration + fraîcheur, fondement de `canAccess`). + */ + private val MIGRATION_15_16 = object : Migration(15, 16) { + override fun migrate(db: SupportSQLiteDatabase) { + db.execSQL( + """ + CREATE TABLE IF NOT EXISTS `resource_permissions` ( + `resource_id` TEXT NOT NULL, + `resource_type` TEXT NOT NULL, + `effective_access` TEXT NOT NULL, + `owner_id` TEXT, + `shared_by_id` TEXT, + `expires_at` INTEGER, + `cached_at` INTEGER NOT NULL, + `updated_at` INTEGER NOT NULL, + PRIMARY KEY(`resource_id`) + ) + """.trimIndent(), + ) + db.execSQL( + "CREATE INDEX IF NOT EXISTS `index_resource_permissions_expires_at` " + + "ON `resource_permissions` (`expires_at`)", + ) + } + } + 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_13_14, + 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, MIGRATION_14_15, MIGRATION_15_16, ) } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt index 16687b6..f256240 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt @@ -140,15 +140,19 @@ data class SyncFailedDto( @Json(name = "message") val message: String, ) -/** Snapshot `GET /sync/permissions` (docs/api-v1.md §6.2). */ +/** + * Snapshot `GET /sync/permissions` (docs/api-v1.md §6.2, miroir de + * `ResourcePermission` Go : `sharedById *string`, `expiresAt *int64` ms epoch). + * M27 : typés (fini les `Any?` jamais lus) — lus par le cache et `canAccess`. + */ data class ResourcePermissionDto( @Json(name = "resource_id") val resourceId: String, @Json(name = "resourceType") val resourceType: String, @Json(name = "effectiveAccess") val effectiveAccess: String, @Json(name = "inherit") val inherit: Boolean, @Json(name = "ownerId") val ownerId: String? = null, - @Json(name = "sharedById") val sharedById: Any? = null, - @Json(name = "expiresAt") val expiresAt: Any? = null, + @Json(name = "sharedById") val sharedById: String? = null, + @Json(name = "expiresAt") val expiresAt: Long? = null, @Json(name = "cachedAt") val cachedAt: Long, @Json(name = "updatedAt") val updatedAt: Long, @Json(name = "name") val name: String = "", 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 be9e39c..237decf 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 @@ -2,6 +2,7 @@ package com.kazier.mobile.data.repository import androidx.room.withTransaction import com.kazier.mobile.data.local.AppDatabase +import com.kazier.mobile.data.local.escapeLike import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.entity.FileEntity @@ -46,10 +47,13 @@ class FileRepository @Inject constructor( /** Fichiers visibles de toute l'arborescence — écran d'accueil (grille par date). */ fun observeAllVisible(): Flow> = fileDao.observeAllVisible() - /** Recherche/filtrage par nom et catégorie (utilisé par SearchViewModel). */ + /** + * Recherche/filtrage par nom et catégorie (utilisé par SearchViewModel). + * m7 : la saisie est échappée (`%`/`_` littéraux, pas des jokers). + */ fun searchFiles(query: String?, category: String?): Flow> = fileDao.searchWithFilters( - query = query?.trim()?.takeIf { it.isNotEmpty() }, + query = query?.trim()?.takeIf { it.isNotEmpty() }?.escapeLike(), category = category, ) @@ -171,6 +175,10 @@ class FileRepository @Inject constructor( suspend fun getAll(): List = fileDao.getAll() + /** Lignes sous une racine SAF (m5) — voir `FolderRepository.getUnderRoot`. */ + suspend fun getUnderRoot(rootUri: String): List = + fileDao.getUnderRoot(rootUri, rootUri.escapeLike()) + /** * Upsert local d'un fichier SAF — miroir de `saveFile()` JS : déduplication * par `resource_id` ou `uri`, conservation de l'identité/sync_status/owner. 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 f9100c1..4f3bf5c 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 @@ -2,6 +2,7 @@ package com.kazier.mobile.data.repository import androidx.room.withTransaction import com.kazier.mobile.data.local.AppDatabase +import com.kazier.mobile.data.local.escapeLike import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.FolderStatus @@ -44,6 +45,13 @@ class FolderRepository @Inject constructor( suspend fun getAll(): List = folderDao.getAll() + /** + * Lignes sous une racine SAF (m5) : la racine est échappée pour le `LIKE` + * (les uris SAF contiennent des `%` d'encodage et parfois des `_`). + */ + suspend fun getUnderRoot(rootUri: String): List = + folderDao.getUnderRoot(rootUri, rootUri.escapeLike()) + /** Snapshot des sous-dossiers visibles d'un dossier (opérations batch hors UI). */ suspend fun getChildren(parentResourceId: String): List = folderDao.getByParentOnce(parentResourceId) @@ -83,7 +91,8 @@ class FolderRepository @Inject constructor( resourceId = dto.id, uri = existing?.uri, name = dto.name, - exists = existing?.exists, + // M13 : une ligne serveur nouvelle n'a pas d'`exists` local — 1 par défaut. + exists = existing?.exists ?: 1, parentResourceId = dto.parentId, ownerId = existing?.ownerId, // Le snapshot serveur confirme la présence cloud : si une copie @@ -144,7 +153,9 @@ class FolderRepository @Inject constructor( resourceId = existing?.resourceId ?: input.resourceId ?: generateId.newResourceId(), uri = input.uri, name = input.name, - exists = input.exists?.let { if (it) 1 else 0 }, + // M13 : `null` (défaut de `SaveFolderInput`) = présent, jamais NULL + // en base — sinon la ligne disparaît des requêtes `exists = 1`. + exists = if (input.exists != false) 1 else 0, parentResourceId = effectiveParent, // `owner_id` Room = user_id du compte actif, jamais l'identité device. ownerId = ownerId ?: existing?.ownerId ?: activeUserStore.get(), diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OcrRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OcrRepository.kt index 1124601..2d0a9f1 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OcrRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OcrRepository.kt @@ -62,12 +62,27 @@ class OcrRepository @Inject constructor( /** * Poll toutes les 3 s (docs §5) jusqu'à l'état terminal. [onProgress] est * appelé à chaque réponse du serveur (état courant exposé à l'UI). + * + * m20 : borné (deadline + nombre max de polls) — un job resté `processing` + * (stale claim serveur) levait sinon une coroutine tenue indéfiniment. + * Le timeout remonte en `ApiException("OCR_TIMEOUT")`, géré comme échec + * par les appelants (`processAuto` → `Failed`, viewer → message d'erreur). */ - suspend fun poll(jobId: String, onProgress: (OcrJobDto) -> Unit = {}): OcrJobDto { + suspend fun poll( + jobId: String, + timeoutMs: Long = POLL_TIMEOUT_MS, + onProgress: (OcrJobDto) -> Unit = {}, + ): OcrJobDto { + val deadline = System.currentTimeMillis() + timeoutMs + var polls = 0 while (true) { val job = apiClient.getOcrJob(jobId) onProgress(job) if (job.status in OcrJobStatus.TERMINAL) return job + polls++ + if (polls >= POLL_MAX_ATTEMPTS || System.currentTimeMillis() >= deadline) { + throw ApiException("OCR_TIMEOUT", "OCR sans réponse (job $jobId)", 0) + } delay(POLL_INTERVAL_MS) } } @@ -144,6 +159,9 @@ class OcrRepository @Inject constructor( companion object { const val POLL_INTERVAL_MS = 3_000L + /** Timeout du poll (m20) : 10 min ≈ 200 polls × 3 s. */ + const val POLL_TIMEOUT_MS = 10 * 60 * 1_000L + const val POLL_MAX_ATTEMPTS = 200 } } 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 8980cf3..ed6c40b 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 @@ -146,6 +146,79 @@ class OutboxRepository @Inject constructor( payload = mapOf("granteeUserId" to granteeUserId), ) + /** + * Raccourci `update_metadata` — payload `{ name }` (rename d'une ressource + * partagée, `editor+`, docs/api-v1.md §6.1). m21 : rend le rename partagé + * émissible — l'op n'avait aucun écrivain côté client. + */ + suspend fun enqueueUpdateMetadata( + resourceId: String, + resourceType: String, + name: String, + ): String = enqueue( + operation = PendingOperationType.UPDATE_METADATA, + resourceId = resourceId, + resourceType = resourceType, + payload = mapOf("name" to name), + ) + + /** + * Raccourci `update_share` — même payload que `share` (m21 : update d'un + * partage existant inopérant sans écrivain). + */ + suspend fun enqueueUpdateShare( + resourceId: String, + resourceType: String, + granteeUserId: String, + access: String, + inherit: Boolean = true, + expiresAt: Long? = null, + ): String = enqueue( + operation = PendingOperationType.UPDATE_SHARE, + resourceId = resourceId, + resourceType = resourceType, + payload = buildMap { + put("granteeUserId", granteeUserId) + put("access", access) + put("inherit", inherit) + expiresAt?.let { put("expiresAt", it) } + }, + ) + + /** + * Raccourci `create_link` — payload `{ token, access, expiresAt? }` + * (m21 : liens publics inopérants sans écrivain). Le `token` 32-hex est + * généré côté client (`GenerateId`) : c'est l'identifiant du lien. + */ + suspend fun enqueueCreateLink( + resourceId: String, + resourceType: String, + token: String, + access: String, + expiresAt: Long? = null, + ): String = enqueue( + operation = PendingOperationType.CREATE_LINK, + resourceId = resourceId, + resourceType = resourceType, + payload = buildMap { + put("token", token) + put("access", access) + expiresAt?.let { put("expiresAt", it) } + }, + ) + + /** Raccourci `revoke_link` — payload `{ token }` (m21). */ + suspend fun enqueueRevokeLink( + resourceId: String, + resourceType: String, + token: String, + ): String = enqueue( + operation = PendingOperationType.REVOKE_LINK, + resourceId = resourceId, + resourceType = resourceType, + payload = mapOf("token" to token), + ) + /** Nombre d'ops en attente de push (stats UI optionnelles). */ suspend fun countPending(): Int = pendingOperationDao.countPending() diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/ShareRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/ShareRepository.kt index 102fa6d..c202698 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/ShareRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/ShareRepository.kt @@ -4,11 +4,15 @@ import androidx.room.withTransaction import com.kazier.mobile.data.local.AppDatabase import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FolderDao +import com.kazier.mobile.data.local.entity.AccessRank import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FolderEntity +import com.kazier.mobile.data.local.entity.ResourcePermissionEntity +import com.kazier.mobile.data.local.entity.UserPreferenceEntity import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.dto.ResourcePermissionDto import com.kazier.mobile.domain.ActiveUserStore +import com.kazier.mobile.domain.PrefKeys import com.kazier.mobile.domain.SyncPlacement import timber.log.Timber import javax.inject.Inject @@ -21,8 +25,17 @@ import javax.inject.Singleton * de l'utilisateur. Les ressources non possédées (viewer/commenter/editor) * sont importées en tant que lignes cloud-only (`uri = NULL`, `sync_status = "cloud"`). * - * Un pull complet (`after=0`) est effectué au login et à la restauration de - * session pour garantir la convergence (révocations = disparition du snapshot). + * M27 — delta, expiration et `canAccess` : + * - le `cachedAt` du dernier pull est persisté (`user_preferences`) : pull + * complet (`after = null`) au premier appel, au login/restauration + * (`forceFull = true`) et quand le cache dépasse le TTL 24h ; delta + * (`after = cachedAt`) sinon — la convergence (lignes absentes = révoquées) + * ne tourne que sur pull complet ; + * - chaque grant non-owner est persisté en `resource_permissions` (rang, + * expiration, fraîcheur) : un grant expiré (`expiresAt` passé) masque la + * ligne locale au lieu de rester visible jusqu'au prochain login ; + * - [canAccess] répond offline (ownership local, puis rang persisté, avec + * downgrade lecture seule après TTL sans reseed). */ @Singleton class ShareRepository @Inject constructor( @@ -32,31 +45,60 @@ class ShareRepository @Inject constructor( ) { /** - * Récupère le snapshot complet des permissions et hydrate Room. + * Récupère le snapshot des permissions et hydrate Room + le cache. * - * Pour chaque permission non-owner : + * Pour chaque permission non-owner non expirée : * - Folders : upsert cloud-only (uri=null, name, parentId, ownerId) * - Files : upsert cloud-only (uri=null, name, folderResourceId, ownerId, processed=true) * - * Convergence : les lignes cloud-only absentes du snapshot complet sont - * marquées `exists = 0`. + * Convergence (pull complet uniquement) : les lignes cloud-only absentes + * du snapshot complet sont marquées `exists = 0`, et les grants du cache + * absents sont oubliés. */ - suspend fun syncSnapshot() { + suspend fun syncSnapshot(forceFull: Boolean = false) { // `ownerId` serveur = user_id : comparer au compte actif, jamais au device. val currentUserId = activeUserStore.get() - val permissions = apiClient.syncPermissions() - + val prefs = appDatabase.userPreferenceDao() + val permDao = appDatabase.resourcePermissionDao() val now = System.currentTimeMillis() + val cachedAt = prefs.getValue(PrefKeys.PERMISSIONS_CACHED_AT)?.toLongOrNull() + val full = forceFull || cachedAt == null || now - cachedAt > PERMISSION_TTL_MS + val permissions = apiClient.syncPermissions(if (full) null else cachedAt) + val folderDao = appDatabase.folderDao() val fileDao = appDatabase.fileDao() val snapshotFolderIds = mutableSetOf() val snapshotFileIds = mutableSetOf() + val snapshotPermIds = mutableSetOf() appDatabase.withTransaction { for (perm in permissions) { + if (perm.effectiveAccess == "owner") continue + snapshotPermIds += perm.resourceId + permDao.upsertAll( + listOf( + ResourcePermissionEntity( + resourceId = perm.resourceId, + resourceType = perm.resourceType, + effectiveAccess = perm.effectiveAccess, + ownerId = perm.ownerId, + sharedById = perm.sharedById, + expiresAt = perm.expiresAt, + // Fraîcheur = heure locale du pull (M27) : le TTL + // mesure « 24h sans reseed », pas l'horloge serveur + // (skew). `perm.cachedAt` sert au delta `after`. + cachedAt = now, + updatedAt = perm.updatedAt, + ), + ), + ) + if (isExpired(perm.expiresAt, now)) { + // Grant expiré : masquer la ligne locale au lieu d'hydrater. + markSharedMissing(perm.resourceId, perm.resourceType, currentUserId, now, folderDao, fileDao) + continue + } when { - perm.effectiveAccess == "owner" -> Unit perm.resourceType == "folder" -> { snapshotFolderIds += perm.resourceId upsertSharedFolder(perm, now, folderDao) @@ -68,36 +110,118 @@ class ShareRepository @Inject constructor( } } - // Convergence : marquer les lignes cloud-only d'autrui absentes du - // snapshot comme disparues (révocation / expiration côté serveur). - // Sans compte actif, impossible d'attribuer : ne rien masquer. Le - // snapshot exclut les ressources possédées → une ligne cloud-only - // au vrai ownerId=user ne doit jamais être markMissing. - for (folder in folderDao.getAll()) { - if (currentUserId != null && - isCloudOnlyForOtherUser(folder.uri, folder.ownerId, currentUserId, folder.exists) && - folder.resourceId !in snapshotFolderIds - ) { - folderDao.markMissing(folder.resourceId, now) + if (full) { + // Convergence : marquer les lignes cloud-only d'autrui absentes du + // snapshot comme disparues (révocation / expiration côté serveur). + // Sans compte actif, impossible d'attribuer : ne rien masquer. Le + // snapshot exclut les ressources possédées → une ligne cloud-only + // au vrai ownerId=user ne doit jamais être markMissing. + for (folder in folderDao.getAll()) { + if (currentUserId != null && + isCloudOnlyForOtherUser(folder.uri, folder.ownerId, currentUserId, folder.exists) && + folder.resourceId !in snapshotFolderIds + ) { + folderDao.markMissing(folder.resourceId, now) + } + } + for (file in fileDao.getAll()) { + if (currentUserId != null && + isCloudOnlyForOtherUser(file.uri, file.ownerId, currentUserId, file.exists) && + file.resourceId !in snapshotFileIds + ) { + fileDao.markMissing(file.resourceId, now) + } + } + // Oublie les grants du cache absents du snapshot complet. + if (snapshotPermIds.isEmpty()) { + permDao.clear() + } else { + permDao.deleteNotIn(snapshotPermIds.toList()) } } - for (file in fileDao.getAll()) { - if (currentUserId != null && - isCloudOnlyForOtherUser(file.uri, file.ownerId, currentUserId, file.exists) && - file.resourceId !in snapshotFileIds - ) { - fileDao.markMissing(file.resourceId, now) - } + + // Grants périmés connus du cache (delta ou TTL) : masquer localement. + for (expired in permDao.getExpired(now)) { + markSharedMissing(expired.resourceId, expired.resourceType, currentUserId, now, folderDao, fileDao) } + + prefs.upsert( + UserPreferenceEntity( + PrefKeys.PERMISSIONS_CACHED_AT, + now.toString(), + now, + ), + ) } Timber.d( - "syncSnapshot: hydrated %d folders, %d files", + "syncSnapshot: hydrated %d folders, %d files (full=%s)", snapshotFolderIds.size, snapshotFileIds.size, + full, ) } + /** + * Droit offline sur une ressource (docs/api-v1.md §6.2) : ownership local + * d'abord (`owner` implique tout), sinon rang persisté du snapshot. + * Grant expiré → refusé ; snapshot périmé (TTL 24h sans reseed) → + * downgrade lecture seule (`viewer` exigé au plus). + */ + suspend fun canAccess(resourceId: String, required: String = AccessRank.VIEWER): Boolean { + val requiredRank = AccessRank.rank(required) + if (requiredRank <= 0) return false + val currentUserId = activeUserStore.get() + val now = System.currentTimeMillis() + if (currentUserId != null) { + val folderOwner = appDatabase.folderDao().getByResourceId(resourceId)?.ownerId + val fileOwner = if (folderOwner == null) { + appDatabase.fileDao().getByResourceId(resourceId)?.ownerId + } else { + null + } + if (folderOwner == currentUserId || fileOwner == currentUserId) return true + } + val perm = appDatabase.resourcePermissionDao().getByResourceId(resourceId) ?: return false + if (isExpired(perm.expiresAt, now)) return false + val effective = if (now - perm.cachedAt > PERMISSION_TTL_MS) { + // Stale : downgrade lecture seule. + minOf(AccessRank.rank(perm.effectiveAccess), AccessRank.rank(AccessRank.VIEWER)) + } else { + AccessRank.rank(perm.effectiveAccess) + } + return effective >= requiredRank + } + + private fun isExpired(expiresAt: Long?, now: Long): Boolean = + expiresAt != null && expiresAt <= now + + /** + * Masque une ligne partagée cloud-only d'autrui (`exists = 0`) — jamais + * une copie physique locale ni une ressource possédée. + */ + private suspend fun markSharedMissing( + resourceId: String, + resourceType: String, + currentUserId: String?, + now: Long, + folderDao: FolderDao, + fileDao: FileDao, + ) { + if (currentUserId == null) return + if (resourceType == "folder") { + val folder = folderDao.getByResourceId(resourceId) ?: return + if (isCloudOnlyForOtherUser(folder.uri, folder.ownerId, currentUserId, folder.exists)) { + folderDao.markMissing(resourceId, now) + } + } else { + val file = fileDao.getByResourceId(resourceId) ?: return + if (isCloudOnlyForOtherUser(file.uri, file.ownerId, currentUserId, file.exists)) { + fileDao.markMissing(resourceId, now) + } + } + } + /** * Ligne hébergée cloud (uri NULL), non possédée localement, encore visible. * Absente du snapshot → ressource partagée révoquée/expirée → marquer disparue. @@ -164,4 +288,9 @@ class ShareRepository @Inject constructor( ) fileDao.upsert(entity) } -} \ No newline at end of file + + companion object { + /** TTL du snapshot permissions (docs/api-v1.md §6.2) : 24h. */ + const val PERMISSION_TTL_MS = 24 * 60 * 60 * 1000L + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/di/DatabaseModule.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/di/DatabaseModule.kt index b8f9fbe..653953e 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/di/DatabaseModule.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/di/DatabaseModule.kt @@ -6,6 +6,7 @@ import com.kazier.mobile.data.local.AppDatabase import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.dao.PendingOperationDao +import com.kazier.mobile.data.local.dao.ResourcePermissionDao import com.kazier.mobile.data.local.dao.ScanDao import com.kazier.mobile.data.local.dao.UserPreferenceDao import com.kazier.mobile.data.local.migration.Migrations @@ -25,6 +26,13 @@ object DatabaseModule { fun provideDatabase(@ApplicationContext context: Context): AppDatabase = Room.databaseBuilder(context, AppDatabase::class.java, "dot.db") .addMigrations(*Migrations.ALL) + // m15 : un APK plus ancien que la DB (downgrade) ne doit plus + // crasher en `IllegalStateException` brut — reconstruction + // destructive documentée : le miroir SAF se reconstruit au walk + // suivant, les données serveur restent la source de vérité. + // Perte acceptée : l'outbox non poussée (mutations locales) — + // cas rare (rollback d'APK), préféré au crash au démarrage. + .fallbackToDestructiveMigrationOnDowngrade() .build() @Provides @@ -41,4 +49,7 @@ object DatabaseModule { @Provides fun provideScanDao(db: AppDatabase): ScanDao = db.scanDao() + + @Provides + fun provideResourcePermissionDao(db: AppDatabase): ResourcePermissionDao = db.resourcePermissionDao() } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt index 43fa1d7..343db8f 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt @@ -8,4 +8,6 @@ object PrefKeys { const val SYNC_MODE = "sync_mode" const val THEME = "theme" const val SERVER_URL = "server_url" + /** Dernier pull `GET /sync/permissions` réussi, ms epoch (M27 : delta + TTL 24h). */ + const val PERMISSIONS_CACHED_AT = "permissions_cached_at" } \ No newline at end of file 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 98c8501..496dc9f 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 @@ -81,19 +81,26 @@ class FileDeleter @Inject constructor( } /** - * Suppression cloud uniquement (outbox `delete_resource`). - * Le fichier local n\'est pas touché. N\'a de sens que si la ressource a - * déjà été poussée (gate « processed » : un fichier jamais envoyé est no-op). + * Suppression cloud uniquement (outbox `delete_resource` + tombstone locale). + * Le fichier physique local n'est pas touché, mais la ligne Room passe + * `exists = 0` dans la MÊME transaction (M5) : sans ça la ressource restait + * affichée, le walk la revoyait et `refreshFromServer` ne supprime jamais + * de lignes → fantôme local vs serveur supprimé. N'a de sens que si la + * ressource a déjà été poussée (gate « processed »). */ private suspend fun deleteInCloud(file: FileEntity): Boolean { var ok = false runCatching { - // 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") + val now = System.currentTimeMillis() + appDatabase.withTransaction { + // 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") + } + fileRepository.markMissing(file.resourceId, now) } ok = true Timber.d("enqueued cloud delete for %s", file.resourceId) 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 423f5e3..632d9cb 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 @@ -87,13 +87,19 @@ class FolderDeleter @Inject constructor( return false } - /** Suppression cloud uniquement (outbox `delete_resource`), physique intact. */ + /** + * Suppression cloud uniquement (outbox `delete_resource` + tombstone locale, + * M5) : le dossier et toute sa descendance Room passent `exists = 0` dans + * la MÊME transaction — le physique reste intact mais l'arbre disparaît de + * l'UI et le walk ne le ressuscite plus (garde `hasPendingDeleteOperation`). + */ private suspend fun deleteInCloud(folder: FolderEntity): Boolean { var ok = false runCatching { - outboxRepository.cancelPendingCreates(folder.resourceId) - if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) { - outboxRepository.enqueueDeleteResource(folder.resourceId, "folder") + val tree = collectDescendants(folder.resourceId) + val now = System.currentTimeMillis() + appDatabase.withTransaction { + treeMarkMissing(folder, tree, now) } ok = true Timber.d("enqueued cloud delete for folder %s", folder.resourceId) diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderMerger.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderMerger.kt index ee2541c..0879e22 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderMerger.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderMerger.kt @@ -29,6 +29,12 @@ import javax.inject.Singleton * * L'ordre outbox est garanti par l'insertion séquentielle : `create_resource` * du dossier fusionné avant les `move_resource`, avant les `delete_resource`. + * + * M9 — reprise après crash : chaque étape est transactionnelle et idempotente + * (dossier réutilisé, contenus déjà déplacés naturellement ignorés), et une + * source n'est supprimée que si elle est réellement vide après déplacement + * (gate de vidage) — jamais de suppression d'un dossier dont le contenu n'a + * pas pu être déplacé, jamais de doublon serveur à la relance. */ @Singleton class FolderMerger @Inject constructor( @@ -68,7 +74,10 @@ class FolderMerger @Inject constructor( val files = fileRepository.getFilesInFolder(src.resourceId) if (files.isNotEmpty()) { fileMover.moveFiles(files.map { it.resourceId }, merged.resourceId) - movedFiles += files.size + // Ne compte que les fichiers réellement partis (relecture : + // `moveFiles` ignore silencieusement les refus SAF, et une + // relance après crash ne doit pas recompter les déjà-déplacés). + movedFiles += files.size - fileRepository.getFilesInFolder(src.resourceId).size } val subFolders = folderRepository.getChildren(src.resourceId) if (subFolders.isNotEmpty()) { @@ -80,6 +89,14 @@ class FolderMerger @Inject constructor( folderRepository.reparentSubFolders(movable.map { it.resourceId }, merged.resourceId) } } + // Gate de vidage (M9) : ne supprimer que les sources + // réellement vidées — un refus SAF silencieux ne doit jamais + // mener à la suppression d'un contenu non déplacé. + val filesLeft = fileRepository.getFilesInFolder(src.resourceId).size + val foldersLeft = folderRepository.getChildren(src.resourceId).size + if (filesLeft > 0 || foldersLeft > 0) { + error("source non vidée : $filesLeft fichier(s), $foldersLeft dossier(s) restants") + } }.isSuccess if (ok) { readyToDelete += src 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 d236776..66205c9 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 @@ -72,43 +72,54 @@ class DeviceSync @Inject constructor( // Phase 1 — listing SAF (I/O disque, HORS transaction). val folders = scanner.scanTree(Uri.parse(rootUri)) - // Phase 2 — écritures Room (transaction courte, SQL pur). - return appDatabase.withTransaction { - val seen = HashSet() - val resourceIdByUri = HashMap() - var fileCount = 0 + // Phase 2 — écritures Room par lots (m5) : chaque lot est sa propre + // transaction courte au lieu d'une transaction géante (N upserts + + // full-table scans sous verrou écriture → lecteurs Room bloqués, + // jank/ANR). L'ordre parent-avant-enfant est préservé (itération + // séquentielle, seules les frontières de commit changent). + val seen = HashSet() + val resourceIdByUri = HashMap() + var fileCount = 0 - for (folder in folders) { - seen += folder.uri - val parentResourceId = if (folder.parentUri == null) { - null - } else { - resourceIdByUri[folder.parentUri] - } - if (folder.parentUri != null && parentResourceId == null) { - // Violation parent-avant-enfant (snapshot incohérent) : on - // n'attache JAMAIS à la racine par défaut — le dossier est - // ignoré et journalisé, le prochain walk convergera. - Timber.w( - "walk: parent SAF inconnu, dossier ignoré (uri=%s parent=%s)", - folder.uri, - folder.parentUri, + for (chunk in folders.chunked(SYNC_BATCH)) { + appDatabase.withTransaction { + for (folder in chunk) { + seen += folder.uri + val parentResourceId = if (folder.parentUri == null) { + null + } else { + resourceIdByUri[folder.parentUri] + } + if (folder.parentUri != null && parentResourceId == null) { + // Violation parent-avant-enfant (snapshot incohérent) : on + // n'attache JAMAIS à la racine par défaut — le dossier est + // ignoré et journalisé, le prochain walk convergera. + Timber.w( + "walk: parent SAF inconnu, dossier ignoré (uri=%s parent=%s)", + folder.uri, + folder.parentUri, + ) + continue + } + val saved = folderRepository.saveFolder( + SaveFolderInput(uri = folder.uri, name = folder.name, exists = true), + parentResourceId = parentResourceId, + ownerId = ownerId, ) - continue + resourceIdByUri[folder.uri] = saved.resourceId } - val saved = folderRepository.saveFolder( - SaveFolderInput(uri = folder.uri, name = folder.name, exists = true), - parentResourceId = parentResourceId, - ownerId = ownerId, - ) - resourceIdByUri[folder.uri] = saved.resourceId } + } - for (folder in folders) { - // Dossier ignoré plus haut (parent manquant) : ses fichiers ne - // sont pas rattachés à la racine, ils attendent le walk suivant. - val folderResourceId = resourceIdByUri[folder.uri] ?: continue - for (file in folder.files) { + val fileWrites = folders.flatMap { folder -> + // Dossier ignoré plus haut (parent manquant) : ses fichiers ne + // sont pas rattachés à la racine, ils attendent le walk suivant. + val folderResourceId = resourceIdByUri[folder.uri] ?: return@flatMap emptyList() + folder.files.map { file -> folderResourceId to file } + } + for (chunk in fileWrites.chunked(SYNC_BATCH)) { + appDatabase.withTransaction { + for ((folderResourceId, file) in chunk) { seen += file.uri fileRepository.saveLocalFile( input = SaveFileInput( @@ -125,45 +136,49 @@ class DeviceSync @Inject constructor( fileCount++ } } - - var missing = 0 - 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 && - !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` 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.hasPendingMoveOperation(file.resourceId) - ) { - fileRepository.markMissing(file.resourceId, now) - outboxRepository.cancelPendingCreates(file.resourceId) - missing++ - } - } - - SyncResult(rootUri = rootUri, folders = folders.size, files = fileCount, missing = missing) } + + var missing = 0 + val now = System.currentTimeMillis() + // Réconciliation scopée à la racine (m5) : fini les `getAll()` + // O(racines×DB) — le SQL filtre par préfixe d'uri (échappé). + for (folder in folderRepository.getUnderRoot(rootUri)) { + val folderUri = folder.uri + if (folder.exists != 0 && folderUri != null && 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.getUnderRoot(rootUri)) { + val fileUri = file.uri + // 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 && fileUri !in seen && + !outboxRepository.hasPendingMoveOperation(file.resourceId) + ) { + fileRepository.markMissing(file.resourceId, now) + outboxRepository.cancelPendingCreates(file.resourceId) + missing++ + } + } + + return SyncResult(rootUri = rootUri, folders = folders.size, files = fileCount, missing = missing) } - private fun isChildOf(uri: String, rootUri: String): Boolean = - uri == rootUri || uri.startsWith("$rootUri/") + companion object { + /** Taille des lots d'upserts Room du walk (m5 : transactions courtes). */ + private const val SYNC_BATCH = 200 + } } private fun String.extensionOrNull(): String? { 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 caf7337..179ccf4 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 @@ -106,31 +106,52 @@ class SyncViewModel @Inject constructor( delay(FIRST_DELAY_MS) while (isActive) { _walkInProgress.value = true - runCatching { deviceSync.syncAll() } - .onSuccess { results -> - if (results.isNotEmpty()) Timber.d("syncAll: %s", results) - // Les nouvelles ressources découvertes sont dans l'outbox - // → drainer vers POST /sync/ops (single-flight via KEEP). - 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") + try { + var changed = false + runCatching { deviceSync.syncAll() } + .onSuccess { results -> + if (results.isNotEmpty()) Timber.d("syncAll: %s", results) + changed = results.any { it.folders > 0 || it.files > 0 || it.missing > 0 } + // 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) + changed = true + } + }.onFailure { e -> + Timber.w(e, "sweep failed, retrying later") + } } + .onFailure { e -> + if (e is CancellationException) throw e + Timber.w(e, "syncAll failed, retrying later") + } + // Hydrate les ressources partagées depuis le snapshot serveur. + // Échec réseau toléré : le prochain tick réessaiera. + runCatching { shareRepository.syncSnapshot() } + .onFailure { e -> + if (e is CancellationException) throw e + Timber.d("syncSnapshot failed, retrying later: %s", e.message) + } + // m2 : ne réveiller WorkManager que si le tick a produit + // quelque chose (walk/sweep) ou si l'outbox attend un drain + // (op partagée depuis l'UI, drain précédent interrompu…). + // Les nouvelles ressources découvertes sont dans l'outbox + // → drainer vers POST /sync/ops (single-flight via KEEP) ; + // OCR auto : octets des fichiers récemment promus. + if (changed || pendingOperationDao.countPending() > 0) { + OutboxSyncWorker.enqueue(appContext) + OcrAutoWorker.enqueue(appContext) } - .onFailure { e -> Timber.w(e, "syncAll failed, retrying later") } - // Hydrate les ressources partagées depuis le snapshot serveur. - // Échec réseau toléré : le prochain tick réessaiera. - runCatching { shareRepository.syncSnapshot() } - .onFailure { e -> Timber.d("syncSnapshot failed, retrying later: %s", e.message) } - _walkInProgress.value = false + } finally { + // m1 : le badge « syncing » retombe même si le scope est + // annulé ou si le snapshot réseau a échoué. + _walkInProgress.value = false + } delay(INTERVAL_MS) } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/auth/AuthViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/auth/AuthViewModel.kt index 30b7e54..37716a3 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/auth/AuthViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/auth/AuthViewModel.kt @@ -50,8 +50,8 @@ class AuthViewModel @Inject constructor( OutboxSyncWorker.enqueue(appContext) OcrAutoWorker.enqueue(appContext) if (session != null) { - // Snapshot complet des permissions partagées (convergence). - runCatching { shareRepository.syncSnapshot() } + // Snapshot complet des permissions partagées (convergence, M27). + runCatching { shareRepository.syncSnapshot(forceFull = true) } .onFailure { e -> Timber.d("syncSnapshot on restore failed: %s", e.message) } } } @@ -72,8 +72,8 @@ class AuthViewModel @Inject constructor( // Connexion réussie → pousser les mutations locales en attente. OutboxSyncWorker.enqueue(appContext) OcrAutoWorker.enqueue(appContext) - // Snapshot complet des permissions partagées (convergence). - runCatching { shareRepository.syncSnapshot() } + // Snapshot complet des permissions partagées (convergence, M27). + runCatching { shareRepository.syncSnapshot(forceFull = true) } .onFailure { e -> Timber.d("syncSnapshot on login failed: %s", e.message) } } .onFailure { e -> diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/SearchEscapeTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/SearchEscapeTest.kt new file mode 100644 index 0000000..7f13d85 --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/SearchEscapeTest.kt @@ -0,0 +1,95 @@ +package com.kazier.mobile.data.local.dao + +import android.content.Context +import androidx.room.Room +import androidx.test.core.app.ApplicationProvider +import com.kazier.mobile.data.local.AppDatabase +import com.kazier.mobile.data.local.entity.FileEntity +import kotlinx.coroutines.flow.first +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 + +/** + * m7 : la recherche `LIKE` échappe `%`/`_` (littéraux, pas des jokers) — + * « 100% » ne matchait pas tout avant le fix. La casse ASCII reste + * insensible (`COLLATE NOCASE`). + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class SearchEscapeTest { + + private lateinit var db: AppDatabase + private lateinit var fileDao: FileDao + + @Before + fun setUp() { + val context = ApplicationProvider.getApplicationContext() + db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java) + .allowMainThreadQueries() + .build() + fileDao = db.fileDao() + } + + @After + fun tearDown() { + db.close() + } + + @Test + fun pourcentage_litteral_ne_match_pas_tout() = runTest { + fileDao.upsert(file("a".repeat(32), "100%.txt")) + fileDao.upsert(file("b".repeat(32), "a_b.txt")) + fileDao.upsert(file("c".repeat(32), "normal.txt")) + + // Le repository échappe avant d'appeler le DAO — on rejoue ici le + // contrat (`escapeLike`) pour verrouiller le comportement SQL. + val escaped = "100%".escapeLikeForTest() + val rows = fileDao.searchWithFilters(escaped, null).first() + + assertEquals(listOf("100%.txt"), rows.map { it.name }) + } + + @Test + fun underscore_litteral_ne_match_pas_tout() = runTest { + fileDao.upsert(file("a".repeat(32), "100%.txt")) + fileDao.upsert(file("b".repeat(32), "a_b.txt")) + fileDao.upsert(file("c".repeat(32), "axb.txt")) + + val rows = fileDao.searchWithFilters("a\\_b", null).first() + + assertEquals(listOf("a_b.txt"), rows.map { it.name }) + } + + @Test + fun recherche_insensible_a_la_casse_ascii() = runTest { + fileDao.upsert(file("a".repeat(32), "Rapport.TXT")) + + val rows = fileDao.searchWithFilters("rapport", null).first() + + assertEquals(listOf("Rapport.TXT"), rows.map { it.name }) + } + + private fun file(resourceId: String, name: String) = FileEntity( + resourceId = resourceId, + name = name, + folderResourceId = "f".repeat(32), + size = 10L, + exists = 1, + addedAt = NOW, + updatedAt = NOW, + ) + + /** Miroir de `escapeLike` (interne au main) : `%`/`_`/`\` échappés. */ + private fun String.escapeLikeForTest(): String = + replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + + private companion object { + const val NOW = 1_700_000_000_000L + } +} diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration14To15Test.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration14To15Test.kt new file mode 100644 index 0000000..1b6ab18 --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration14To15Test.kt @@ -0,0 +1,100 @@ +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.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** + * M13 : la migration 14→15 backfill `exists` NULL→1 sur `folders` et `files`. + * Les lignes insérées sans `exists` explicite (défaut Kotlin `null` avant ce + * fix) étaient invisibles des requêtes `WHERE exists = 1` — elles + * réapparaissent comme présentes, état le plus sûr (le walk les re-marque + * `exists = 0` si elles ont vraiment disparu). Les lignes déjà à 0/1 sont + * intactes. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class Migration14To15Test { + + @Test + fun migration_backfill_exists_null_vers_1_sans_toucher_les_lignes_renseignees() { + val context = ApplicationProvider.getApplicationContext() + val helper = FrameworkSQLiteOpenHelperFactory().create( + SupportSQLiteOpenHelper.Configuration.builder(context) + .name(null) + .callback(V14Callback()) + .build(), + ) + val db = helper.writableDatabase + db.execSQL( + "INSERT INTO `folders` (`resource_id`, `name`, `exists`, `sync_status`, `added_at`, `updated_at`) " + + "VALUES ('f-null', 'Null', NULL, 'local', 1, 1), ('f-zero', 'Zero', 0, 'local', 1, 1), ('f-one', 'One', 1, 'local', 1, 1)", + ) + db.execSQL( + "INSERT INTO `files` (`resource_id`, `name`, `folder_resource_id`, `size`, `exists`, `added_at`, `updated_at`) " + + "VALUES ('d-null', 'n.txt', 'f-one', 10, NULL, 1, 1), ('d-zero', 'z.txt', 'f-one', 10, 0, 1, 1)", + ) + + val migration = Migrations.ALL.first { it.startVersion == 14 && it.endVersion == 15 } + migration.migrate(db) + + db.query("SELECT `resource_id`, `exists` FROM `folders` ORDER BY `resource_id`").use { cursor -> + val rows = mutableMapOf() + while (cursor.moveToNext()) rows[cursor.getString(0)] = cursor.getInt(1) + assertEquals(mapOf("f-null" to 1, "f-one" to 1, "f-zero" to 0), rows) + } + db.query("SELECT `resource_id`, `exists` FROM `files` ORDER BY `resource_id`").use { cursor -> + val rows = mutableMapOf() + while (cursor.moveToNext()) rows[cursor.getString(0)] = cursor.getInt(1) + assertEquals(mapOf("d-null" to 1, "d-zero" to 0), rows) + } + helper.close() + } + + /** Schéma v14 minimal de `folders`/`files` (colonne `exists` nullable). */ + private class V14Callback : SupportSQLiteOpenHelper.Callback(14) { + override fun onCreate(db: SupportSQLiteDatabase) { + db.execSQL( + "CREATE TABLE `folders` (" + + "`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " + + "`resource_id` TEXT NOT NULL, " + + "`uri` TEXT, " + + "`name` TEXT NOT NULL, " + + "`exists` INTEGER, " + + "`parent_resource_id` TEXT, " + + "`owner_id` TEXT, " + + "`sync_status` TEXT NOT NULL, " + + "`created_in_app` INTEGER NOT NULL DEFAULT 0, " + + "`added_at` INTEGER NOT NULL, " + + "`updated_at` INTEGER NOT NULL)", + ) + db.execSQL( + "CREATE TABLE `files` (" + + "`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " + + "`resource_id` TEXT NOT NULL, " + + "`uri` TEXT, " + + "`name` TEXT NOT NULL, " + + "`folder_resource_id` TEXT NOT NULL, " + + "`extension` TEXT, " + + "`size` INTEGER NOT NULL, " + + "`mime_type` TEXT, " + + "`exists` INTEGER, " + + "`added_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/local/migration/Migration15To16Test.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration15To16Test.kt new file mode 100644 index 0000000..2d10d4a --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration15To16Test.kt @@ -0,0 +1,79 @@ +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.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** + * M27 : la migration 15→16 crée la table `resource_permissions` (cache du + * snapshot `GET /sync/permissions`, fondement de `canAccess`) + son index + * `expires_at`. Une coquille SQL briquerait l'app au démarrage après update. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class Migration15To16Test { + + @Test + fun migration_cree_la_table_et_l_index() { + val context = ApplicationProvider.getApplicationContext() + val helper = FrameworkSQLiteOpenHelperFactory().create( + SupportSQLiteOpenHelper.Configuration.builder(context) + .name(null) + .callback(EmptyV15Callback()) + .build(), + ) + val db = helper.writableDatabase + + val migration = Migrations.ALL.first { it.startVersion == 15 && it.endVersion == 16 } + migration.migrate(db) + + val tables = mutableListOf() + db.query( + "SELECT `name` FROM `sqlite_master` WHERE `type` = 'table' AND `name` = 'resource_permissions'", + ).use { cursor -> + while (cursor.moveToNext()) tables += cursor.getString(0) + } + assertTrue("table resource_permissions manquante", tables.contains("resource_permissions")) + + val columns = mutableListOf() + db.query("PRAGMA table_info(`resource_permissions`)").use { cursor -> + val nameIdx = cursor.getColumnIndexOrThrow("name") + while (cursor.moveToNext()) columns += cursor.getString(nameIdx) + } + for (expected in listOf( + "resource_id", "resource_type", "effective_access", "owner_id", + "shared_by_id", "expires_at", "cached_at", "updated_at", + )) { + assertTrue("colonne $expected manquante", columns.contains(expected)) + } + + var indexFound = false + db.query("PRAGMA index_list(`resource_permissions`)").use { cursor -> + val nameIdx = cursor.getColumnIndexOrThrow("name") + while (cursor.moveToNext()) { + if (cursor.getString(nameIdx) == "index_resource_permissions_expires_at") { + indexFound = true + } + } + } + assertTrue("index expires_at manquant", indexFound) + helper.close() + } + + private class EmptyV15Callback : SupportSQLiteOpenHelper.Callback(15) { + override fun onCreate(db: SupportSQLiteDatabase) = Unit + + override fun onUpgrade( + db: SupportSQLiteDatabase, + oldVersion: Int, + newVersion: Int, + ) = Unit + } +} diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt index 7d82309..fb710dc 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt @@ -11,6 +11,7 @@ import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileStatus import com.kazier.mobile.data.remote.ApiClient +import com.kazier.mobile.data.remote.ApiException import com.kazier.mobile.data.remote.ApiService import com.kazier.mobile.data.remote.dto.ApiEnvelope import com.kazier.mobile.data.remote.dto.ChangePasswordDto @@ -109,6 +110,24 @@ class OcrRepositoryTest { assertEquals("bonjour monde", stored?.ocrText) } + @Test + fun `poll_timeout_si_job_bloque_en_processing`() = runTest { + // m20 : un job resté `processing` (stale claim serveur) ne tient plus + // la coroutine indéfiniment — `OCR_TIMEOUT` au bout du timeout. + apiService.jobSequence = listOf( + OcrJobDto(id = "job-stuck", status = OcrJobStatus.PROCESSING), + ) + + var progressCalls = 0 + val ex = runCatching { + repository.poll("job-stuck", timeoutMs = 0) { progressCalls++ } + }.exceptionOrNull() + + assertTrue(ex is ApiException) + assertEquals("OCR_TIMEOUT", (ex as ApiException).code) + assertEquals(1, progressCalls) + } + @Test fun `poll_stop_sur_un_job_failed_et_remonte_lerreur`() = runTest { apiService.jobSequence = listOf( diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt index d6ce938..f922a42 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt @@ -232,22 +232,146 @@ class ShareRepositoryTest { assertEquals(1, folderDao.getByResourceId("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")!!.exists) } + // --- delta / TTL (M27) --------------------------------------------------- + + @Test + fun premier_pull_complet_puis_delta() = runTest { + apiService.permissions = listOf( + perm(id = FOLDER_ID, type = "folder", access = "viewer", name = "S", parentId = null), + ) + + shareRepository.syncSnapshot() + assertNull("premier pull : snapshot complet (after=null)", apiService.lastAfter) + + shareRepository.syncSnapshot() + assertTrue( + "second pull : delta (after=cachedAt)", + apiService.lastAfter != null, + ) + } + + @Test + fun forceFull_repasse_en_complet_meme_avec_cache() = runTest { + apiService.permissions = emptyList() + + shareRepository.syncSnapshot() + shareRepository.syncSnapshot(forceFull = true) + + assertNull("forceFull : snapshot complet (after=null)", apiService.lastAfter) + } + + @Test + fun delta_ne_fait_pas_converger_les_absents() = runTest { + // Pull complet initial avec une ressource partagée… + activeUserStore.set(CURRENT_USER) + apiService.permissions = listOf( + perm(id = FOLDER_ID, type = "folder", access = "viewer", name = "S", parentId = null), + ) + shareRepository.syncSnapshot() + assertEquals(1, folderDao.getByResourceId(FOLDER_ID)!!.exists) + + // …puis delta vide : la ressource NE doit pas être marquée disparue + // (un delta ne contient que les changements, pas l'état complet). + apiService.permissions = emptyList() + shareRepository.syncSnapshot() + + assertEquals(1, folderDao.getByResourceId(FOLDER_ID)!!.exists) + } + + // --- expiration (M27) ------------------------------------------------------ + + @Test + fun grant_expire_masque_la_ligne_au_lieu_d_hydrater() = runTest { + activeUserStore.set(CURRENT_USER) + folderDao.upsert(folder(FOLDER_ID, uri = null, ownerId = OTHER_USER)) + apiService.permissions = listOf( + perm( + id = FOLDER_ID, type = "folder", access = "viewer", name = "S", parentId = null, + expiresAt = NOW - 1_000L, + ), + ) + + shareRepository.syncSnapshot() + + assertEquals(0, folderDao.getByResourceId(FOLDER_ID)!!.exists) + } + + // --- canAccess (M27) --------------------------------------------------------- + + @Test + fun canAccess_ownership_rang_expiration() = runTest { + activeUserStore.set(CURRENT_USER) + // Ressource possédée localement → owner implicite. + folderDao.upsert(folder(OWNED_ID, uri = null, ownerId = CURRENT_USER)) + // Grants partagés. + apiService.permissions = listOf( + perm(id = FOLDER_ID, type = "folder", access = "editor", name = "E", parentId = null), + perm(id = FILE_ID, type = "file", access = "viewer", name = "v.pdf", parentId = FOLDER_ID), + ) + shareRepository.syncSnapshot() + + assertTrue(shareRepository.canAccess(OWNED_ID, "editor")) + assertTrue(shareRepository.canAccess(FOLDER_ID, "editor")) + assertTrue("viewer suffit pour viewer", shareRepository.canAccess(FILE_ID, "viewer")) + assertFalse("viewer < editor", shareRepository.canAccess(FILE_ID, "editor")) + assertFalse("ressource inconnue", shareRepository.canAccess("d".repeat(32), "viewer")) + } + + @Test + fun canAccess_grant_expire_refuse() = runTest { + activeUserStore.set(CURRENT_USER) + apiService.permissions = listOf( + perm( + id = FOLDER_ID, type = "folder", access = "editor", name = "E", parentId = null, + expiresAt = NOW - 1_000L, + ), + ) + shareRepository.syncSnapshot() + + assertFalse("grant expiré : pas d'accès", shareRepository.canAccess(FOLDER_ID, "viewer")) + } + + @Test + fun canAccess_snapshot_perime_downgrade_lecture_seule() = runTest { + activeUserStore.set(CURRENT_USER) + apiService.permissions = listOf( + perm(id = FOLDER_ID, type = "folder", access = "editor", name = "E", parentId = null), + ) + shareRepository.syncSnapshot() + assertTrue(shareRepository.canAccess(FOLDER_ID, "editor")) + + // Simule un cache périmé (TTL 24h dépassé sans reseed). + val stale = db.resourcePermissionDao().getByResourceId(FOLDER_ID)!! + db.resourcePermissionDao().upsertAll( + listOf(stale.copy(cachedAt = System.currentTimeMillis() - ShareRepository.PERMISSION_TTL_MS - 1)), + ) + + assertTrue("stale : lecture conservée", shareRepository.canAccess(FOLDER_ID, "viewer")) + assertFalse("stale : écriture refusée", shareRepository.canAccess(FOLDER_ID, "editor")) + } + // --- fixtures ------------------------------------------------------------ - private fun perm(id: String, type: String, access: String, name: String, parentId: String?) = - ResourcePermissionDto( - resourceId = id.padEnd(32, '0'), - resourceType = type, - effectiveAccess = access, - inherit = true, - ownerId = OTHER_USER, - sharedById = OWNER_ID, - expiresAt = null, - cachedAt = NOW, - updatedAt = NOW, - name = name, - parentId = parentId?.padEnd(32, '0'), - ) + private fun perm( + id: String, + type: String, + access: String, + name: String, + parentId: String?, + expiresAt: Long? = null, + ) = ResourcePermissionDto( + resourceId = id.padEnd(32, '0'), + resourceType = type, + effectiveAccess = access, + inherit = true, + ownerId = OTHER_USER, + sharedById = OWNER_ID, + expiresAt = expiresAt, + cachedAt = NOW, + updatedAt = NOW, + name = name, + parentId = parentId?.padEnd(32, '0'), + ) private fun folder(id: String, uri: String?, ownerId: String?) = FolderEntity( resourceId = id.padEnd(32, '0'), @@ -290,6 +414,7 @@ class ShareRepositoryTest { /** Fake `ApiService` — uniquement le snapshot est réellement consommé. */ private class FakeApiService : ApiService { var permissions: List = emptyList() + var lastAfter: Long? = null override suspend fun listFolders(): Response>> = Response.success(ApiEnvelope(data = emptyList())) @@ -319,8 +444,10 @@ private class FakeApiService : ApiService { override suspend fun syncPermissions( after: Long?, - ): Response>> = - Response.success(ApiEnvelope(data = permissions)) + ): Response>> { + lastAfter = after + return Response.success(ApiEnvelope(data = permissions)) + } override suspend fun uploadFile( file: MultipartBody.Part, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/DeleteInCloudTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/DeleteInCloudTest.kt new file mode 100644 index 0000000..c485176 --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/DeleteInCloudTest.kt @@ -0,0 +1,168 @@ +package com.kazier.mobile.features.saf + +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.dao.PendingOperationDao +import com.kazier.mobile.data.local.entity.PendingOperationType +import com.kazier.mobile.data.remote.ApiClient +import com.kazier.mobile.data.remote.ApiService +import com.kazier.mobile.data.repository.FileRepository +import com.kazier.mobile.data.repository.FolderRepository +import com.kazier.mobile.data.repository.OutboxRepository +import com.kazier.mobile.data.repository.SaveFileInput +import com.kazier.mobile.data.repository.SaveFolderInput +import com.kazier.mobile.domain.ActiveUserStore +import com.kazier.mobile.domain.DeviceIdentity +import com.kazier.mobile.domain.GenerateId +import com.kazier.mobile.features.thumbnails.ThumbnailStore +import kotlinx.coroutines.test.runTest +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import retrofit2.Retrofit +import retrofit2.converter.moshi.MoshiConverterFactory + +/** + * M5 : `deleteInCloud` journalise `delete_resource` ET pose la tombstone + * locale (`exists = 0`) dans la même transaction — sans ça la ressource + * restait affichée et le walk la revoyait (fantôme local vs serveur supprimé). + * - fichier déjà poussé (create synced) → `delete_resource` + `exists = 0` ; + * - fichier jamais poussé → pas de `delete_resource`, mais `exists = 0` ; + * - dossier poussé → dossier + descendance en `exists = 0`, deletes journalisés. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class DeleteInCloudTest { + + private lateinit var context: Context + private lateinit var db: AppDatabase + private lateinit var opsDao: PendingOperationDao + private lateinit var fileRepository: FileRepository + private lateinit var folderRepository: FolderRepository + private lateinit var outboxRepository: OutboxRepository + private lateinit var fileDeleter: FileDeleter + private lateinit var folderDeleter: FolderDeleter + + @Before + fun setUp() { + context = ApplicationProvider.getApplicationContext() + db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java) + .allowMainThreadQueries() + .build() + opsDao = db.pendingOperationDao() + + val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build() + val apiService = Retrofit.Builder() + .baseUrl("http://localhost:1/") + .addConverterFactory(MoshiConverterFactory.create(moshi)) + .build() + .create(ApiService::class.java) + val apiClient = ApiClient(apiService, moshi) + val generateId = GenerateId() + val deviceIdentity = DeviceIdentity(db.userPreferenceDao(), generateId) + val activeUserStore = ActiveUserStore(db.userPreferenceDao()) + + outboxRepository = OutboxRepository(opsDao, generateId, deviceIdentity, moshi) + fileRepository = FileRepository(db.fileDao(), db.folderDao(), apiClient, generateId, db, outboxRepository) + folderRepository = FolderRepository(db.folderDao(), apiClient, generateId, activeUserStore, db, outboxRepository) + val thumbnails = ThumbnailStore(context) + fileDeleter = FileDeleter(context, fileRepository, outboxRepository, db, thumbnails) + folderDeleter = FolderDeleter(context, folderRepository, fileRepository, outboxRepository, db, thumbnails) + } + + @After + fun tearDown() { + db.close() + } + + @Test + fun fichier_pousse_delete_cloud_pose_tombstone_et_journalise() = runTest { + val folder = folderRepository.saveFolder(SaveFolderInput(uri = FOLDER_URI, name = "R", exists = true)) + fileRepository.saveLocalFile( + input = SaveFileInput(uri = FILE_URI, name = "a.txt", size = 10, resourceId = FILE_ID, processed = true), + folderResourceId = folder.resourceId, + ) + markSynced(FILE_ID, PendingOperationType.CREATE_RESOURCE) + + val report = fileDeleter.deleteFiles( + listOf(db.fileDao().getByResourceId(FILE_ID)!!), + FileDeleter.DeleteMode.IN_CLOUD, + ) + + assertEquals(1, report.succeeded) + assertEquals(0, db.fileDao().getByResourceId(FILE_ID)!!.exists) + val deletes = opsDao.selectPending(100).filter { + it.resourceId == FILE_ID && it.operation == PendingOperationType.DELETE_RESOURCE + } + assertEquals(1, deletes.size) + } + + @Test + fun fichier_jamais_pousse_delete_cloud_sans_delete_resource_mais_masque() = runTest { + val folder = folderRepository.saveFolder(SaveFolderInput(uri = FOLDER_URI, name = "R", exists = true)) + fileRepository.saveLocalFile( + input = SaveFileInput(uri = FILE_URI, name = "a.txt", size = 10, resourceId = FILE_ID, processed = false), + folderResourceId = folder.resourceId, + ) + + val report = fileDeleter.deleteFiles( + listOf(db.fileDao().getByResourceId(FILE_ID)!!), + FileDeleter.DeleteMode.IN_CLOUD, + ) + + assertEquals(1, report.succeeded) + assertEquals(0, db.fileDao().getByResourceId(FILE_ID)!!.exists) + val deletes = opsDao.selectPending(100).filter { + it.resourceId == FILE_ID && it.operation == PendingOperationType.DELETE_RESOURCE + } + assertTrue("jamais poussé : aucun delete_resource", deletes.isEmpty()) + } + + @Test + fun dossier_pousse_delete_cloud_masque_tout_l_arbre() = runTest { + val folder = folderRepository.saveFolder(SaveFolderInput(uri = FOLDER_URI, name = "R", exists = true)) + fileRepository.saveLocalFile( + input = SaveFileInput(uri = FILE_URI, name = "a.txt", size = 10, resourceId = FILE_ID, processed = true), + folderResourceId = folder.resourceId, + ) + markSynced(folder.resourceId, PendingOperationType.CREATE_RESOURCE) + markSynced(FILE_ID, PendingOperationType.CREATE_RESOURCE) + + val report = folderDeleter.deleteFolders( + listOf(db.folderDao().getByResourceId(folder.resourceId)!!), + FileDeleter.DeleteMode.IN_CLOUD, + ) + + assertEquals(1, report.succeeded) + assertEquals(0, db.folderDao().getByResourceId(folder.resourceId)!!.exists) + assertEquals(0, db.fileDao().getByResourceId(FILE_ID)!!.exists) + val deletes = opsDao.selectPending(100).filter { + it.operation == PendingOperationType.DELETE_RESOURCE + }.map { it.resourceId }.toSet() + assertTrue(deletes.contains(folder.resourceId)) + assertTrue(deletes.contains(FILE_ID)) + } + + private suspend fun markSynced(resourceId: String, operation: String) { + val op = opsDao.selectPending(100).first { + it.resourceId == resourceId && it.operation == operation + } + opsDao.markSynced(op.id, NOW) + } + + private companion object { + const val NOW = 1_700_000_000_000L + const val FOLDER_URI = "content://tree/root" + const val FILE_URI = "content://tree/root/a.txt" + const val FILE_ID = "aabbccddeeff11223344556677889900" + } +}